Adds the given group vertex to this management stage.

@param groupVertex
the group vertex to be added to this management stage
777219
void addGroupVertex(final ManagementGroupVertex groupVertex) {

		this.groupVertices.add(groupVertex);

		this.managementGraph.addGroupVertex(groupVertex.getID(), groupVertex);
	}
527179
public OGraphVertex unlink(final OGraphVertex iTargetVertex) {
		if (iTargetVertex == null)
			throw new IllegalArgumentException("Missed the target vertex");

		unlink(database, document, iTargetVertex.getDocument());

		return this;
	}
574983
def add_group(self, L):
        
        if len(L) == 1:
            self.add(L[0])
        elif len(L) >= 2:
            x = PQ_node(P_shape)
            x.add_all(L)
            self.add(x)
233260
public void add(Object vertex) {
        if (vertex == null || vertices.containsKey(vertex)) {
            return;
        }

        checkGraphSize();

        vertices.put(vertex, new VertexMetadata(freeList.removeFirst()));
        vertexModCount++;
    }
1117058
public final boolean expandGroup(final int groupIndex) {
        ExpandableListAdapter adapter = getExpandableListAdapter();

        if (adapter != null && !isGroupExpanded(groupIndex)) {
            expandedGroups.add(groupIndex);
            notifyDataSetChanged();
            return true;
        }

        return false;
    }
1192608
private void insertInheritedGroups(final Class<?> clazz, final GroupChain chain) {
    validationGroupsMetadata.getParentsOfGroup(clazz).forEach(inheritedGroup -> {
      final Group group = new Group(inheritedGroup);
      chain.insertGroup(group);
      insertInheritedGroups(inheritedGroup, chain);
    });
  }
1142879
private void addEdgesForVertex(Vertex vertex)
    {
        ClassDescriptor cld = vertex.getEnvelope().getClassDescriptor();
        Iterator rdsIter = cld.getObjectReferenceDescriptors(true).iterator();
        while (rdsIter.hasNext())
        {
            ObjectReferenceDescriptor rds = (ObjectReferenceDescriptor) rdsIter.next();
            addObjectReferenceEdges(vertex, rds);
        }
        Iterator cdsIter = cld.getCollectionDescriptors(true).iterator();
        while (cdsIter.hasNext())
        {
            CollectionDescriptor cds = (CollectionDescriptor) cdsIter.next();
            addCollectionEdges(vertex, cds);
        }
    }
426608
public void addEdge(VertexT from, VertexT to) {
    Preconditions.checkArgument(vertices.containsKey(from) && vertices.containsKey(to));
    adjacencyList.put(from, to);
    vertices.put(to, vertices.get(to) + 1);
  }
265588
public void assignGroup(XEvent event, String group) {
		if (group != null && group.trim().length() > 0) {
			XAttributeLiteral attr = (XAttributeLiteral) ATTR_GROUP.clone();
			attr.setValue(group.trim());
			event.getAttributes().put(KEY_GROUP, attr);
		}
	}
1192094
public void removeVertex(AtlasVertex vertex) {
        String vertexString = null;

        if (LOG.isDebugEnabled()) {
            vertexString = string(vertex);

            LOG.debug("Removing {}", vertexString);
        }

        graph.removeVertex(vertex);

        if (LOG.isDebugEnabled()) {
            LOG.info("Removed {}", vertexString);
        }
    }
1219164
public void addGroup(TimelineGroup group) {
        if (groups == null) {
            groups = new ArrayList<>();
        }

        groups.add(group);
    }
127394
public final void addBracket(SgroupBracket bracket) {
        List<SgroupBracket> brackets = getValue(SgroupKey.CtabBracket);
        if (brackets == null) {
            putValue(SgroupKey.CtabBracket,
                     brackets = new ArrayList<>(2));
        }
        brackets.add(bracket);
    }
112474
public void setThingGroupsToAdd(java.util.Collection<String> thingGroupsToAdd) {
        if (thingGroupsToAdd == null) {
            this.thingGroupsToAdd = null;
            return;
        }

        this.thingGroupsToAdd = new java.util.ArrayList<String>(thingGroupsToAdd);
    }
696961
void registerExecutionVertex(final ExecutionVertex vertex) {

		if (this.vertexMap.put(vertex.getID(), vertex) != null) {
			throw new IllegalStateException("There is already an execution vertex with ID " + vertex.getID()
				+ " registered");
		}
	}
378598
public void addGroupBy(String[] fieldNames)
    {
        for (int i = 0; i < fieldNames.length; i++)
        {
            addGroupBy(fieldNames[i]);
        }
    }
645877
private void addGroup(List<Token> group, List<List<Token>> groups) {

    if(group.isEmpty()) return;

    // remove trailing tokens that should be ignored
    while(!group.isEmpty() && IGNORED_TRAILING_TOKENS.contains(
        group.get(group.size() - 1).getType())) {
      group.remove(group.size() - 1);
    }

    // if the group still has some tokens left, we'll add it to our list of groups
    if(!group.isEmpty()) {
      groups.add(group);
    }
  }
683545
public void setGroupList(java.util.Collection<Group> groupList) {
        if (groupList == null) {
            this.groupList = null;
            return;
        }

        this.groupList = new java.util.ArrayList<Group>(groupList);
    }