Returns the modifiable list of root groups.

@return The modifiable list of root groups.
15329
public List<Group> getRootGroups()
    {
        List<Group> results = this.cachedRootGroups;
        
        if(results == null)
        {
            synchronized(this)
            {
                results = this.cachedRootGroups;
                if(results == null)
                {
                    results = new ArrayList<Group>();
                    
                    RepositoryConnection conn = null;
                    
                    try
                    {
                        conn = this.getRepository().getConnection();
                        
                        final RepositoryResult<Statement> rootGroupStatements =
                                conn.getStatements(null, RDF.TYPE, SesameRealmConstants.OAS_ROOTGROUP, true,
                                        this.getContexts());
                        
                        try
                        {
                            while(rootGroupStatements.hasNext())
                            {
                                final Statement nextRootGroupStatement = rootGroupStatements.next();
                                
                                if(nextRootGroupStatement.getSubject() instanceof URI)
                                {
                                    final URI nextRootGroupUri = (URI)nextRootGroupStatement.getSubject();
                                    // add the group recursively to enable member groups to be added
                                    // recursively
                                    results.add(this.createGroupHierarchy(null, conn, nextRootGroupUri));
                                }
                                else
                                {
                                    this.log.warn("Not including root group as it did not have a URI identifier: {}",
                                            nextRootGroupStatement);
                                }
                            }
                        }
                        finally
                        {
                            rootGroupStatements.close();
                        }
                    }
                    catch(final RepositoryException e)
                    {
                        this.log.error("Found exception while trying to get root groups", e);
                    }
                    finally
                    {
                        try
                        {
                            if(conn != null)
                            {
                                conn.close();
                            }
                        }
                        catch(final RepositoryException e)
                        {
                            this.log.error("Found unexpected exception while closing repository connection", e);
                        }
                    }
                    
                    this.cachedRootGroups = results;
                }
            }
        }
        
        return results;
        
        // throw new RuntimeException(
        // "TODO: Implement code not to rely on getting a complete list of groups where possible");
        // return this.rootGroups;
    }
1261967
public List<T> getRoots() {
    List<T> roots = new ArrayList<>();
    for (DirectedAcyclicGraphNode<T> root : mRoots) {
      roots.add(root.getPayload());
    }
    return roots;
  }
327183
def RootGroup(self):
		

		return(clc.v2.Group(id=self.root_group_id,alias=self.alias,session=self.session))
183258
public List<I_CmsXmlSchemaType> getRegisteredSchemaTypes() {

        List<I_CmsXmlSchemaType> result = new ArrayList<I_CmsXmlSchemaType>(m_registeredTypes.values());
        Collections.sort(result);
        return result;
    }
1235009
public List<Classification.RuntimeClassification> getClassifications() {
    List<Classification.RuntimeClassification> result = new ArrayList<>();
    getClassifications(result, tree.getRoot());
    return result;
  }
961268
public List<Action> getRootActions() {
		final List<Action> rootActions = srcUpdTrees.stream().map(t -> originalActionsSrc.get(t))
				.collect(Collectors.toList());

		rootActions.addAll(srcDelTrees.stream() //
				.filter(t -> !srcDelTrees.contains(t.getParent()) && !srcUpdTrees.contains(t.getParent())) //
				.map(t -> originalActionsSrc.get(t)) //
				.collect(Collectors.toList()));

		rootActions.addAll(dstAddTrees.stream() //
				.filter(t -> !dstAddTrees.contains(t.getParent()) && !dstUpdTrees.contains(t.getParent())) //
				.map(t -> originalActionsDst.get(t)) //
				.collect(Collectors.toList()));

		rootActions.addAll(dstMvTrees.stream() //
				.filter(t -> !dstMvTrees.contains(t.getParent())) //
				.map(t -> originalActionsDst.get(t)) //
				.collect(Collectors.toList()));

		rootActions.removeAll(Collections.singleton(null));
		return rootActions;
	}
1276667
public java.util.List<String> getGroupIds() {
        if (groupIds == null) {
            groupIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return groupIds;
    }
747416
public void setRootGroups(final List<Group> rootGroups)
    {
        synchronized(this.getRootGroups())
        {
            if(rootGroups != this.getRootGroups())
            {
                this.getRootGroups().clear();
                
                if(rootGroups != null)
                {
                    this.getRootGroups().addAll(rootGroups);
                }
            }
        }
    }
1214187
public List<GenericType> getGenericParameterTypes() {
        if (root.children.isEmpty()) {
            return null;
        }

        List<GenericType> genericParameters = new ArrayList<GenericType>();
        putAllChildren(root, genericParameters);
        return unmodifiableList(new ArrayList<GenericType>(genericParameters));
    }
1333019
public Set<String> getRoles() {
        HashSet<String> rolescopy;
        rolescopy = new HashSet<>(roles);
        return Collections.unmodifiableSet(rolescopy);
    }
60468
public String[] getDecisionPathNames() {
      int classTrees = 0;
      for (int i = 0; i < _ntrees_per_group; ++i) {
        int itree = treeIndex(0, i);
        if (_compressed_trees[itree] != null) classTrees++;
      }
      final int outputcols = _ntree_groups * classTrees;
      final String[] names = new String[outputcols];
      for (int c = 0; c < _ntrees_per_group; c++) {
        for (int tidx = 0; tidx < _ntree_groups; tidx++) {
          int itree = treeIndex(tidx, c);
          if (_compressed_trees[itree] != null) {
            names[itree] = "T" + (tidx + 1) + ".C" + (c + 1);
          }
        }
      }
      return names;
    }
1085208
public java.util.List<ReservedInstancesModificationResult> getModificationResults() {
        if (modificationResults == null) {
            modificationResults = new com.amazonaws.internal.SdkInternalList<ReservedInstancesModificationResult>();
        }
        return modificationResults;
    }
1104215
public java.util.List<AutoScalingGroup> getAutoScalingGroups() {
        if (autoScalingGroups == null) {
            autoScalingGroups = new com.amazonaws.internal.SdkInternalList<AutoScalingGroup>();
        }
        return autoScalingGroups;
    }
1364705
public java.util.List<String> getInstanceGroupTypes() {
        if (instanceGroupTypes == null) {
            instanceGroupTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instanceGroupTypes;
    }
739259
public java.util.List<GroupDetail> getGroupDetailList() {
        if (groupDetailList == null) {
            groupDetailList = new com.amazonaws.internal.SdkInternalList<GroupDetail>();
        }
        return groupDetailList;
    }
617521
def get_groups(self):
        
        def process_result(result):
            return [self.get_group(group) for group in result]

        return Command('get', [ROOT_GROUPS], process_result=process_result)
636278
public java.util.List<LoadBalancerTargetGroupState> getLoadBalancerTargetGroups() {
        if (loadBalancerTargetGroups == null) {
            loadBalancerTargetGroups = new com.amazonaws.internal.SdkInternalList<LoadBalancerTargetGroupState>();
        }
        return loadBalancerTargetGroups;
    }