Returns a {@link Set} of {@link Node}s potentially affected by an
incremental classification.

@return
552384
public Set<Node> getAffectedNodes() {
        Set<Node> res = new HashSet<Node>();
        for(IntIterator it = getNewSubsumptions().keyIterator(); 
                        it.hasNext(); ) {
            String key = factory.lookupConceptId(it.next()).toString();
            Node n = conceptNodeIndex.get(key);
            if(n != null) {
                res.add(n);
            } else {
                log.debug("Could not find node for key " + key);
            }
        }
        for(IntIterator it = getAffectedSubsumptions().keyIterator(); 
                        it.hasNext(); ) {
            String key = factory.lookupConceptId(it.next()).toString();
            Node n = conceptNodeIndex.get(key);
            if(n != null) {
                res.add(n);
            } else {
                log.debug("Could not find node for key " + key);
            }
        }
        return res;
    }
1364386
public Set<Category> getSiblings() {
        Set<Category> siblings = new HashSet<Category>();

        // add siblings
        for (Category parent : this.getParents()) {
            siblings.addAll(parent.getChildren());
        }

        // remove this category from list
        siblings.remove(this);

        return siblings;
    }
13712
public int[][] getSets() {
        int n = 0;
        for (int i = 0; i < forest.length; i++) {
            if (forest[i] < 0) {
                n++;
            }
        }
        int[][] sets = new int[n][];
        int currentSet = 0;
        for (int i = 0; i < forest.length; i++) {
            if (forest[i] < 0) {
                int setSize = 1 - forest[i] - 1;
                sets[currentSet] = new int[setSize];
                int currentIndex = 0;
                for (int element = 0; element < forest.length; element++) {
                    if (getRoot(element) == i) {
                        sets[currentSet][currentIndex] = element;
                        currentIndex++;
                    }
                }
                currentSet++;
            }
        }
        return sets;
    }
1111558
public Set<Weighted<DirectedEdge>> directedEdges(Map<NodeId, Node> nodes) {
        return Collections.emptySet();
    }
1040012
public Set<String> keySet(){
		HashSet<String> set=new HashSet<String>();
		Iterator<String> keys=keys();
		while(keys.hasNext()){
			set.add(keys.next());
		}
		return set;
	}
42162
@XmlTransient
  public Set<QueryAnnotation> getEdgeAnnotations()
  {
    Set<QueryAnnotation> edgeAnnotations = new TreeSet<>();
    
    for(Join j : ingoingJoins)
    {
      edgeAnnotations.addAll(j.getEdgeAnnotations());
    }
    
    return Collections.unmodifiableSet(edgeAnnotations);
  }
507848
public List<Node> getNodes(Collection<Long> nodeIds)
	{
		if(nodeIds.isEmpty()) return Collections.emptyList();
		return getSomeElements(NODE + "s?" + NODE + "s=" + toCommaList(nodeIds), Node.class);
	}
340900
public List<Node> childNodesCopy() {
        final List<Node> nodes = ensureChildNodes();
        final ArrayList<Node> children = new ArrayList<>(nodes.size());
        for (Node node : nodes) {
            children.add(node.clone());
        }
        return children;
    }
760930
public final Set<Map.Entry<K,V>> entrySet() {

	return new AbstractSet<Map.Entry<K,V>>() {
	    public Iterator<Map.Entry<K,V>> iterator() {
		return entryIterator();
	    }
	    public int size() {
		return size;
	    }
	};
    }
60629
public java.util.List<String> getRestorableNodeTypes() {
        if (restorableNodeTypes == null) {
            restorableNodeTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return restorableNodeTypes;
    }
243707
public Set<? extends Element> getSpecifiedElements() {
        if (specifiedElements == null) {
            Set<Element> result = new LinkedHashSet<>();
            result.addAll(specifiedModuleElements);
            result.addAll(specifiedPackageElements);
            result.addAll(specifiedTypeElements);
            specifiedElements = Collections.unmodifiableSet(result);
        }
        return specifiedElements;
    }
416545
public TreeSet<String> getAllRelations() {
		TreeSet<String> set = new TreeSet<String>(); 
		Iterator<FNLPDoc> it1 = docs.iterator();
		while(it1.hasNext()){
			FNLPDoc doc = it1.next();
			Iterator<FNLPSent> it2 = doc.sentences.iterator();
			while(it2.hasNext()){
				FNLPSent sent = it2.next();
				if(!sent.hasRelation())
					continue;
				for(int i=0;i<sent.size();i++){					
					set.add(sent.relations[i]);
				}
			}

		}
		return set;
		
	}
973754
public Set<T> types() {
        // NOTE: purely unoptimized!
        Set<T> types = new HashSet<T>();
        for (Object o : edges.values()) {
            Set<T> s = (Set<T>)o;
            types.addAll(s);
        }
        return types;
    }
407620
public List<NodeInfo> getNodes() {
    final URI uri = uriWithPath("./nodes/");
    return Arrays.asList(this.rt.getForObject(uri, NodeInfo[].class));
  }
920701
public Iterator<String> keySet()
    {
        Node node = getNode(true);
        NodeList nodeList = node.getChildNodes();
        return new NodeIterator(nodeList);
    }
478806
public Set<Class<?>> getPrevented() {
        if (this.prevent == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(this.prevent);
    }
300861
@Pure
	public SortedSet<Integer> toSortedSet() {
		final SortedSet<Integer> theset = new TreeSet<>();
		if (this.values != null) {
			for (int idxStart = 0; idxStart < this.values.length - 1; idxStart += 2) {
				for (int n = this.values[idxStart]; n <= this.values[idxStart + 1]; ++n) {
					theset.add(n);
				}
			}
		}
		return theset;
	}