Recursively gets all of the groups and sequence groups in the map (children and parents alike)
in one flat set.

@return set of groups
964598
public Set<Class<?>> getAllGroupsAndSequences() {
    final Set<Class<?>> allGroups = new HashSet<>();
    for (final Map.Entry<Class<?>, Set<Class<?>>> entry : inheritanceMapping.entrySet()) {
      allGroups.add(entry.getKey());
      allGroups.addAll(entry.getValue());
    }
    allGroups.addAll(sequenceMapping.keySet());
    return allGroups;
  }
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;
    }
766364
public Set<N> getChildren(N n)
    {
        Pair<HashSet<N>, HashSet<N>> p = nodes.get(n);
        
        if(p == null)
            return null;
        
        return p.getOutgoing();
    }
1256720
public Set<Map.Entry<String, CacheEntry>> entrySet() {
		Set<Map.Entry<String, CacheEntry>> result = Collections.emptySet();
		NavigableMap<String, CacheEntry> navMap = new TreeMap<String, CacheEntry>(map);
		String from = navMap.ceilingKey(keyPrefix), to = navMap.lowerKey(keyPrefixUpperBound);
		if (from != null) {
			result = navMap.subMap(from, true, to, true).entrySet();
		}
		return result;
	}
53831
@Override
    public Collection<N> getNodes() {
        List<N> nodes = new ArrayList<>();
        Iterables.addAll(nodes, GraphTraversal.breadthFirstOrder(this, Collections.singleton(root)));
        return nodes;
    }
994815
public List<Family> getFamilies() {
        final List<Family> families = new ArrayList<>();
        for (final FamilyNavigator nav : familySNavigators) {
            families.add(nav.getFamily());
        }
        return families;
    }
100498
private Collection<Group> findGroups(Session session, Group parent, boolean recursive) throws Exception
   {
      List<Group> groups = new ArrayList<Group>();
      String parentId = parent == null ? "" : parent.getId();

      NodeIterator childNodes = utils.getGroupNode(session, parentId).getNodes();

      while (childNodes.hasNext())
      {
         Node groupNode = childNodes.nextNode();
         if (!groupNode.getName().startsWith(JCROrganizationServiceImpl.JOS_MEMBERSHIP))
         {
            Group group = readGroup(groupNode);
            groups.add(group);

            if (recursive)
            {
               groups.addAll(findGroups(session, group, recursive));
            }
         }
      }

      return groups;
   }
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;
    }
1331359
public List<SequenceGenerator<EntityMappings<T>>> getAllSequenceGenerator()
   {
      List<SequenceGenerator<EntityMappings<T>>> list = new ArrayList<SequenceGenerator<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("sequence-generator");
      for(Node node: nodeList)
      {
         SequenceGenerator<EntityMappings<T>>  type = new SequenceGeneratorImpl<EntityMappings<T>>(this, "sequence-generator", childNode, node);
         list.add(type);
      }
      return list;
   }
899098
@Override
    public Iterator findParentGroups(IGroupMember gm) throws GroupsException {
        if (gm.isGroup()) {
            IEntityGroup group = (IEntityGroup) gm;
            return findParentGroups(group);
        } else {
            IEntity ent = (IEntity) gm;
            return findParentGroups(ent);
        }
    }
676905
public Set<Symbol> getCommonGroupingColumns()
    {
        Set<Symbol> intersection = new HashSet<>(groupingSets.get(0));
        for (int i = 1; i < groupingSets.size(); i++) {
            intersection.retainAll(groupingSets.get(i));
        }
        return ImmutableSet.copyOf(intersection);
    }
773979
public java.util.List<GroupIdentifier> getGroups() {
        if (groups == null) {
            groups = new com.amazonaws.internal.SdkInternalList<GroupIdentifier>();
        }
        return groups;
    }
104540
public Collection<TopicPartition> getTopicPartitions() {
        Collection<TopicPartitionGroup> topicPartitions = getTopicPartitionGroups();
        Set<TopicPartition> tps = new HashSet<TopicPartition>();
        if (topicPartitions != null) {
            for (TopicPartitionGroup g : topicPartitions) {
                tps.addAll(g.getTopicPartitions());
            }
        }
        return tps;
    }
950987
public SortedSet<Entry> getChildEntries() throws IOException {
        if (children == null) {
            if (isFile() || rootNodeDId == -1) {
                children = NO_CHILDREN;
            }
            else {
                // Start at root node in R/B tree, and read to the left and right,
                // re-build tree, according to the docs
                children = Collections.unmodifiableSortedSet(document.getEntries(rootNodeDId, this));
            }
        }

        return children;
    }
624817
public List<Entity> getAllChildrenRecursive() {
        List<Entity> result = newArrayList();
        if (isRoot()) {
            allChildrenRecursive(this, result);
        }
        return result;
    }
156080
public final Set<String> getCategories()
	{
		final Set<String> categories = new TreeSet<String>();
		if (parentNode != null)
		{
			categories.addAll(parentNode.getCategories());
		}
		if (accessor instanceof CategoryAware)
		{
			final Set<String> categoriesFromAccessor = ((CategoryAware) accessor).getCategoriesFromAnnotation();
			if (categoriesFromAccessor != null)
			{
				categories.addAll(categoriesFromAccessor);
			}
		}
		categories.addAll(additionalCategories);

		return unmodifiableSet(categories);
	}
922763
public List<String> getRootChildren() {

        List<String> children = new ArrayList<String>();
        try {
            children = zk.getChildren("/", false);
        } catch (KeeperException e) {
            LOGGER.error(e.toString());
        } catch (InterruptedException e) {
            LOGGER.error(e.toString());
        }

        return children;
    }