getAllNodeUids - Gets all the internal uids of all nodes, their children, and all their children so on..

              @return set<uuid.UUID>
764882
def getAllNodeUids(self):
        '''
            
        '''
        ret = set()

        for child in self:
            ret.update(child.getAllNodeUids())

        return ret
1268134
public List<InternalBDDNode> getInternalNodes(final int bdd) {
    final List<InternalBDDNode> result = new ArrayList<>();
    for (final int[] node : this.kernel.allNodes(bdd))
      result.add(new InternalBDDNode(node[0], this.idx2var.get(node[1]).name(), node[2], node[3]));
    return result;
  }

  private BDDNode getInnerNode(final int index, final BDDConstant falseNode, final BDDConstant trueNode,
                               final Map<Integer, BDDInnerNode> innerNodes) {
    if (index == BDDKernel.BDD_FALSE)
      return falseNode;
    else if (index == BDDKernel.BDD_TRUE)
      return trueNode;
    else {
      return innerNodes.get(index);
    }
  }

  /**
   * Returns the BDD Kernel of this factory.  The Kernel should only be accessed when you know, what you are doing.
   * @return the BDD Kernel
   */
  public BDDKernel underlyingKernel() {
    return this.kernel;
  }

  /**
   * Returns the formula factory for this BDD factory.
   * @return the formula factory
   */
  public FormulaFactory getF() {
    return this.f;
  }

  /**
   * A internal representation of BDD nodes.  Only for internal usage.
   */
  public static class InternalBDDNode {
    private final int nodenum;
    private final String label;
    private final int low;
    private final int high;

    /**
     * Constructs a new internal BDD node.
     * @param nodeNum the node number
     * @param label   the label
     * @param low     the low node number
     * @param high    the high node number
     */
    private InternalBDDNode(final int nodeNum, final String label, final int low, final int high) {
      this.nodenum = nodeNum;
      this.label = label;
      this.low = low;
      this.high = high;
    }

    /**
     * Returns the node number.
     * @return the node number
     */
    public int nodenum() {
      return this.nodenum;
    }

    /**
     * Returns the label.
     * @return the label
     */
    public String label() {
      return this.label;
    }

    /**
     * Returns the low node number.
     * @return the low node number
     */
    public int low() {
      return this.low;
    }

    /**
     * Returns the high node number.
     * @return the high node number
     */
    public int high() {
      return this.high;
    }
  }
}
285472
public List<Id<Attributes<T>>> getAllId()
   {
      List<Id<Attributes<T>>> list = new ArrayList<Id<Attributes<T>>>();
      List<Node> nodeList = childNode.get("id");
      for(Node node: nodeList)
      {
         Id<Attributes<T>>  type = new IdImpl<Attributes<T>>(this, "id", childNode, node);
         list.add(type);
      }
      return list;
   }
974631
public Set<BeanId> getIds() {
        Set<BeanId> ids = new HashSet<>();
        ids.addAll(beansQuery);
        ids.addAll(beans.keySet());
        return ids;
    }
1192368
public function getNativelyNodeChildren($nodeUid)
    {
        $query = $this->createQueryBuilder('s')
                ->select('s._uid', 's._leftnode')
                ->where('s._parent = :node')
                ->addOrderBy('s._leftnode', 'asc')
                ->addOrderBy('s._modified', 'desc')
                ->getQuery()
                ->getSQL();

        $result = $this->getEntityManager()
                ->getConnection()
                ->executeQuery((string) $query, [$nodeUid], [\Doctrine\DBAL\Types\Type::STRING])
                ->fetchAll();

        return Collection::array_column($result, 'uid0');
    }
285575
protected static List<SpecNode> getAllSpecNodes(final Level level) {
        final List<SpecNode> specNodes = new ArrayList<SpecNode>();

        for (final Node childNode : level.getChildNodes()) {
            if (childNode instanceof SpecNode) {
                specNodes.add((SpecNode) childNode);
            }

            if (childNode instanceof Level) {
                specNodes.addAll(getAllSpecNodes((Level) childNode));
            }
        }

        return specNodes;
    }
1166114
def getDescendantsUIDs(self, all_descendants=False):
        
        descendants = self.getDescendants(all_descendants=all_descendants)
        return map(api.get_uid, descendants)
1247984
public Collection<Xml> getChildren()
    {
        final Collection<Xml> nodes = new ArrayList<>(1);
        final NodeList list = root.getChildNodes();
        for (int i = 0; i < list.getLength(); i++)
        {
            final Node node = list.item(i);
            if (node instanceof Element)
            {
                nodes.add(new Xml(document, (Element) node));
            }
        }
        return nodes;
    }
1059474
public static List<CSNodeWrapper> getAllChildrenNodes(final CSNodeWrapper csNode) {
        final List<CSNodeWrapper> nodes = new LinkedList<CSNodeWrapper>();
        if (csNode.getChildren() != null) {
            final List<CSNodeWrapper> childrenNodes = csNode.getChildren().getItems();
            for (final CSNodeWrapper childNode : childrenNodes) {
                nodes.add(childNode);
                nodes.addAll(getAllChildrenNodes(childNode));
            }
        }

        return nodes;
    }
766364
public Set<N> getChildren(N n)
    {
        Pair<HashSet<N>, HashSet<N>> p = nodes.get(n);
        
        if(p == null)
            return null;
        
        return p.getOutgoing();
    }
53831
@Override
    public Collection<N> getNodes() {
        List<N> nodes = new ArrayList<>();
        Iterables.addAll(nodes, GraphTraversal.breadthFirstOrder(this, Collections.singleton(root)));
        return nodes;
    }
1292887
public Set<SortedSet<T>> allSets() {
        final List<UBNode<T>> allEndOfPathNodes = getAllEndOfPathNodes(this.rootNodes);
        final Set<SortedSet<T>> allSets = new LinkedHashSet<>();
        for (UBNode<T> endOfPathNode : allEndOfPathNodes) {
            allSets.add(endOfPathNode.set());
        }
        return allSets;
    }
975758
public static Set<UUID> getEntityIDsRecursively(final EntityContainer container) {
	final Set<UUID> result = new HashSet<>();

	walkEntityTree(container,
		e -> result.add(e.getID()) ? EntityVisitResult.CONTINUE : EntityVisitResult.IGNORE_CHILDREN);

	return result;
    }
432966
public Set<String> getNeverGroupedIds() {
        String s = props.getProperty("neverGroupedIds");
        if(s == null) return Collections.emptySet();
        
        Set<String> res = new HashSet<String>();
        String[] parts = s.split("[,]");
        for(String part : parts) {
            res.add(part);
        }
        return res;
    }
162342
public Collection<C> getAll(Collection<String> ids){
		Set<C> list = new LinkedHashSet<C>();

		for(String id : ids){
			C container = get(id);

			if(container != null){
				list.add(container);
			}
		}

		return list;
	}
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;
    }
1288884
public java.util.List<String> getInstanceIdSet() {
        if (instanceIdSet == null) {
            instanceIdSet = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instanceIdSet;
    }