com.sun.jdi.ThreadGroupReference Java Examples

/**
 * Creates a new translated node for given original one.
 *
 * @param o a node to be translated
 * @return a new translated node
 */
private Object createTranslation (Object o) {
    switch (translationID) {
        case THREAD_ID:
            if (o instanceof ThreadReference) {
                return new JPDAThreadImpl ((ThreadReference) o, debugger);
            } else if (o instanceof ThreadGroupReference) {
                return new JPDAThreadGroupImpl ((ThreadGroupReference) o, debugger);
            } else {
                return null;
            }
        case LOCALS_ID:
            if (o instanceof ArrayType) {
                return new JPDAArrayTypeImpl(debugger, (ArrayType) o);
            }
            if (o instanceof ReferenceType) {
                return new JPDAClassTypeImpl(debugger, (ReferenceType) o);
            }
        default:
            throw new IllegalStateException(""+o);
    }
}
 

public ThreadsCache getThreadsCache() {
    synchronized (threadsCollectorLock) {
        if (threadsCache == null) {
            threadsCache = new ThreadsCache(this);
            threadsCache.addPropertyChangeListener(new PropertyChangeListener() {
                //  Re-fire the changes
                @Override
                public void propertyChange(PropertyChangeEvent evt) {
                    String propertyName = evt.getPropertyName();
                    if (ThreadsCache.PROP_THREAD_STARTED.equals(propertyName)) {
                        firePropertyChange(PROP_THREAD_STARTED, null, getThread((ThreadReference) evt.getNewValue()));
                    }
                    if (ThreadsCache.PROP_THREAD_DIED.equals(propertyName)) {
                        firePropertyChange(PROP_THREAD_DIED, getThread((ThreadReference) evt.getOldValue()), null);
                    }
                    if (ThreadsCache.PROP_GROUP_ADDED.equals(propertyName)) {
                        firePropertyChange(PROP_THREAD_GROUP_ADDED, null, getThreadGroup((ThreadGroupReference) evt.getNewValue()));
                    }
                }
            });
        }
        return threadsCache;
    }
}
 

public synchronized List<ThreadGroupReference> getTopLevelThreadGroups() {
    boolean uninitialized;
    if (groupMap == null) {
        groupMap = new HashMap<ThreadGroupReference, List<ThreadGroupReference>>();
        uninitialized = true;
    } else {
        uninitialized = false;
    }
    List<ThreadGroupReference> topGroups = groupMap.get(null);
    if (topGroups == null) {
        if (vm == null) {
            return Collections.emptyList();
        }
        topGroups = new ArrayList<>(VirtualMachineWrapper.topLevelThreadGroups0(vm));
        groupMap.put(null, topGroups);
        if (uninitialized) {
            for (ThreadGroupReference g : topGroups) {
                groupMap.put(g, uninitializedGroupList);
            }
        }
    }
    return Collections.<List<ThreadReference>>unmodifiableList(new ArrayList(topGroups));
}
 

private void initGroups(ThreadGroupReference group) {
    try {
        List<ThreadGroupReference> groups = new ArrayList<>(ThreadGroupReferenceWrapper.threadGroups0(group));
        List<ThreadReference> threads = new ArrayList<>(ThreadGroupReferenceWrapper.threads0(group));
        filterThreads(threads);
        groupMap.put(group, groups);
        threadMap.put(group, threads);
        for (ThreadGroupReference g : groups) {
            initGroups(g);
        }
    } catch (ObjectCollectedException e) {
    }
}
 

public JPDAThreadGroup[] getTopLevelThreadGroups() {
    ThreadsCache tc = getThreadsCache();
    if (tc == null) {
        return new JPDAThreadGroup[0];
    }
    List<ThreadGroupReference> groupList = tc.getTopLevelThreadGroups();
    JPDAThreadGroup[] groups = new JPDAThreadGroup[groupList.size()];
    for (int i = 0; i < groups.length; i++) {
        groups[i] = getThreadGroup((ThreadGroupReference) groupList.get(i));
    }
    return groups;
}
 

static ThreadGroupReference find(String name) {
    ThreadGroupIterator tgi = new ThreadGroupIterator();
    while (tgi.hasNext()) {
        ThreadGroupReference tg = tgi.nextThreadGroup();
        if (tg.name().equals(name)) {
            return tg;
        }
    }
    return null;
}
 

static ThreadGroupReference find(String name) {
    ThreadGroupIterator tgi = new ThreadGroupIterator();
    while (tgi.hasNext()) {
        ThreadGroupReference tg = tgi.nextThreadGroup();
        if (tg.name().equals(name)) {
            return tg;
        }
    }
    return null;
}
 

static ThreadGroupReference group() {
    if (group == null) {
        // Current thread group defaults to the first top level
        // thread group.
        setThreadGroup(Env.vm().topLevelThreadGroups().get(0));
    }
    return group;
}
 

/**
 * The invariant in this class is that the top iterator
 * on the stack has more elements.  If the stack is
 * empty, there is no top.  This method assures
 * this invariant.
 */
private void push(List<ThreadGroupReference> tgl) {
    stack.push(tgl.iterator());
    while (!stack.isEmpty() && !top().hasNext()) {
        stack.pop();
    }
}
 

/**
 * The invariant in this class is that the top iterator
 * on the stack has more elements.  If the stack is
 * empty, there is no top.  This method assures
 * this invariant.
 */
private void push(List<ThreadGroupReference> tgl) {
    stack.push(tgl.iterator());
    while (!stack.isEmpty() && !top().hasNext()) {
        stack.pop();
    }
}
 

static ThreadGroupReference find(String name) {
    ThreadGroupIterator tgi = new ThreadGroupIterator();
    while (tgi.hasNext()) {
        ThreadGroupReference tg = tgi.nextThreadGroup();
        if (tg.name().equals(name)) {
            return tg;
        }
    }
    return null;
}
 

public JPDAThreadGroupImpl[] getThreadGroups () {
    ThreadsCache tc = debugger.getThreadsCache();
    if (tc == null) {
        return new JPDAThreadGroupImpl[0];
    }
    List<ThreadGroupReference> l = tc.getGroups(tgr);
    int i, k = l.size ();
    JPDAThreadGroupImpl[] ts = new JPDAThreadGroupImpl[k];
    for (i = 0; i < k; i++) {
        ts [i] = (JPDAThreadGroupImpl) debugger.getThreadGroup(l.get (i));
    }
    return ts;
}
 

/**
 * The invariant in this class is that the top iterator
 * on the stack has more elements.  If the stack is
 * empty, there is no top.  This method assures
 * this invariant.
 */
private void push(List<ThreadGroupReference> tgl) {
    stack.push(tgl.iterator());
    while (!stack.isEmpty() && !top().hasNext()) {
        stack.pop();
    }
}
 

static ThreadGroupReference find(String name) {
    ThreadGroupIterator tgi = new ThreadGroupIterator();
    while (tgi.hasNext()) {
        ThreadGroupReference tg = tgi.nextThreadGroup();
        if (tg.name().equals(name)) {
            return tg;
        }
    }
    return null;
}
 

/**
 * The invariant in this class is that the top iterator
 * on the stack has more elements.  If the stack is
 * empty, there is no top.  This method assures
 * this invariant.
 */
private void push(List<ThreadGroupReference> tgl) {
    stack.push(tgl.iterator());
    while (!stack.isEmpty() && !top().hasNext()) {
        stack.pop();
    }
}
 

private void fillAllGroups(List<ThreadGroupReference> groups, ThreadGroupReference g) {
    List<ThreadGroupReference> gs = groupMap.get(g);
    if (gs != null) {
        if (gs == uninitializedGroupList) {
            gs = new ArrayList<>(ThreadGroupReferenceWrapper.threadGroups0(g));
            groupMap.put(g, gs);
        }
        groups.addAll(gs);
        for (ThreadGroupReference gg : gs) {
            fillAllGroups(groups, gg);
        }
    }
}
 

/**
 * The invariant in this class is that the top iterator
 * on the stack has more elements.  If the stack is
 * empty, there is no top.  This method assures
 * this invariant.
 */
private void push(List<ThreadGroupReference> tgl) {
    stack.push(tgl.iterator());
    while (!stack.isEmpty() && !top().hasNext()) {
        stack.pop();
    }
}
 

static ThreadGroupReference group() {
    if (group == null) {
        // Current thread group defaults to the first top level
        // thread group.
        setThreadGroup(Env.vm().topLevelThreadGroups().get(0));
    }
    return group;
}
 

public ThreadGroupReference nextThreadGroup() {
    ThreadGroupReference tg = top().next();
    push(tg.threadGroups());
    return tg;
}
 

ThreadGroupIterator(List<ThreadGroupReference> tgl) {
    push(tgl);
}
 

ThreadGroupIterator(ThreadGroupReference tg) {
    List<ThreadGroupReference> tgl = new ArrayList<ThreadGroupReference>();
    tgl.add(tg);
    push(tgl);
}
 

@Override
public ThreadGroupReference next() {
    return nextThreadGroup();
}
 

public JPDAThreadGroup getThreadGroup (ThreadGroupReference tgr) {
    return (JPDAThreadGroup) threadsTranslation.translate (tgr);
}
 

ThreadGroupIterator(List<ThreadGroupReference> tgl) {
    push(tgl);
}
 

public ThreadGroupIterator(List<ThreadGroupReference> tgl) {
    push(tgl);
}
 

public ThreadGroupIterator(List<ThreadGroupReference> tgl) {
    push(tgl);
}
 

ThreadIterator(ThreadGroupReference tg) {
    tgi = new ThreadGroupIterator(tg);
}
 

private Iterator<ThreadGroupReference> top() {
    return stack.peek();
}
 

@Override
public ThreadGroupReference next() {
    return nextThreadGroup();
}
 

public ThreadIterator(ThreadGroupReference tg) {
    tgi = new ThreadGroupIterator(tg);
}