Returns all the session/reactor artifacts topologically sorted.

@return
772112
private Set<Artifact> getSessionArtifacts() {
        Set<Artifact> result = new LinkedHashSet<Artifact>();
        for (MavenProject p : getSession().getProjectDependencyGraph().getSortedProjects()) {
            result.add(p.getArtifact());
        }
        return result;
    }
1284880
public java.util.List<InstancePatchState> getInstancePatchStates() {
        if (instancePatchStates == null) {
            instancePatchStates = new com.amazonaws.internal.SdkInternalList<InstancePatchState>();
        }
        return instancePatchStates;
    }
52534
public List<ChangesContainer> getSortedList()
   {
      List<ChangesContainer> changesContainers = new ArrayList<ChangesContainer>(changes);
      Collections.sort(changesContainers);
      return changesContainers;
   }
220663
public List<ManagementGroupVertex> getGroupVerticesInTopologicalOrder() {

		final List<ManagementGroupVertex> topologicalSort = new ArrayList<ManagementGroupVertex>();
		final Deque<ManagementGroupVertex> noIncomingEdges = new ArrayDeque<ManagementGroupVertex>();
		final Map<ManagementGroupVertex, Integer> indegrees = new HashMap<ManagementGroupVertex, Integer>();

		final Iterator<ManagementGroupVertex> it = new ManagementGroupVertexIterator(this, true, -1);
		while (it.hasNext()) {
			final ManagementGroupVertex groupVertex = it.next();
			indegrees.put(groupVertex, Integer.valueOf(groupVertex.getNumberOfBackwardEdges()));
			if (groupVertex.getNumberOfBackwardEdges() == 0) {
				noIncomingEdges.add(groupVertex);
			}
		}

		while (!noIncomingEdges.isEmpty()) {

			final ManagementGroupVertex groupVertex = noIncomingEdges.removeFirst();
			topologicalSort.add(groupVertex);
			// Decrease indegree of connected vertices
			for (int i = 0; i < groupVertex.getNumberOfForwardEdges(); i++) {
				final ManagementGroupVertex targetVertex = groupVertex.getForwardEdge(i).getTarget();
				Integer indegree = indegrees.get(targetVertex);
				indegree = Integer.valueOf(indegree.intValue() - 1);
				indegrees.put(targetVertex, indegree);
				if (indegree.intValue() == 0) {
					noIncomingEdges.add(targetVertex);
				}

			}
		}

		return topologicalSort;
	}
639467
public List<SessionBeanType<EnterpriseBeansType<T>>> getAllSession()
   {
      List<SessionBeanType<EnterpriseBeansType<T>>> list = new ArrayList<SessionBeanType<EnterpriseBeansType<T>>>();
      List<Node> nodeList = childNode.get("session");
      for(Node node: nodeList)
      {
         SessionBeanType<EnterpriseBeansType<T>>  type = new SessionBeanTypeImpl<EnterpriseBeansType<T>>(this, "session", childNode, node);
         list.add(type);
      }
      return list;
   }
49319
public final List<AbstractTraceRegion> getNestedRegions() {
		if (nestedRegions == null)
			return Collections.emptyList();
		return Collections.unmodifiableList(nestedRegions);
	}
582993
public List<List<Object>> getParameterSets() {
        List<List<Object>> result = new LinkedList<>();
        if (routeUnit.getSqlUnit().getParameters().isEmpty() || 0 == actualCallAddBatchTimes) {
            result.add(Collections.emptyList());
        } else {
            result.addAll(Lists.partition(routeUnit.getSqlUnit().getParameters(), routeUnit.getSqlUnit().getParameters().size() / actualCallAddBatchTimes));
        }
        return result;
    }
494426
public List<ServiceStatus> getAllStatuses() {
        List<ServiceStatus> list = getCriticalStatuses();
        list.addAll(getNonCriticalStatuses());
        return list;
    }
450281
public Set<SocketAddress> getCurrentSessionAddresses() {
        Set<SocketAddress> result = new HashSet<SocketAddress>();
        synchronized (lock) {
            result.addAll(sessions.keySet());
            result.addAll(pendingConnections.keySet());
        }
        return result;
    }
188767
public synchronized Collection<T> getAll() {
    List<T> all = new ArrayList<T>(size);
    for (T e = head; e != null; e = e.getNext()) {
      all.add(e);
    }
    return all;
  }
206431
public ImmutableSet<ClassInfo> getTopLevelClasses() {
    return FluentIterable.from(resources).filter(ClassInfo.class).filter(IS_TOP_LEVEL).toImmutableSet();
  }
20742
public Collection essentialCycles() {
        Collection result = new HashSet();
        //minimize();

        for (Object subgraphBase : subgraphBases) {
            SimpleCycleBasis cycleBasis = (SimpleCycleBasis) subgraphBase;
            result.addAll(cycleBasis.essentialCycles());
        }

        return result;
    }
375497
public List<V> reverseTopologicalSort() {
        List<V> list = topologicalSort();
        if (list == null) {
            return null;
        }

        Collections.reverse(list);

        return list;
    }
637198
public java.util.List<ResourceRecordSet> getResourceRecordSets() {
        if (resourceRecordSets == null) {
            resourceRecordSets = new com.amazonaws.internal.SdkInternalList<ResourceRecordSet>();
        }
        return resourceRecordSets;
    }
871600
private static List<SessionStatus> getEndStates() {
    List<SessionStatus> endStatesRet = new ArrayList<SessionStatus>();
    for (SessionStatus s : SessionStatus.values()) {
      if (s != SessionStatus.RUNNING) {
        endStatesRet.add(s);
      }
    }
    return endStatesRet;
  }
420999
public Collection<String> getIgnoreHosts() {
        if (isIgnoreLocalhost()) {
            return new ImmutableSet.Builder<String>()
                    .addAll(ignoreHosts)
                    .addAll(Network.getLocalAddresses())
                    .build();
        } else {
            return ignoreHosts;
        }
    }
1016184
public List<T> getAll() {
		List<T> result = new ArrayList<T>();
		if (nodes != null)
			for(Node element : nodes) 
				result.add(getCachedOrNewRepresentation(element));
		return result;
	}
	
	public int size() {
		return nodes.size();
	}
	
	public T get(int index) {
		return getCachedOrNewRepresentation(nodes.get(index));
	}
		
	public Iterator<T> iterator() {
		return getAll().iterator();
	}
}