Create a container with the given GroupContainerPopulator which will hold
the members of this group.

@param groupContainerPopulator
762753
protected void addCommandsToGroupContainer(final GroupContainerPopulator groupContainerPopulator) {
		final Iterator members = getMemberList().iterator();

		while (members.hasNext()) {
			final GroupMember member = (GroupMember) members.next();
			if (member.getCommand() instanceof CommandGroup) {
				member.fill(groupContainerPopulator, getButtonFactory(), getPullDownMenuButtonConfigurer(),
						Collections.EMPTY_LIST);
			}
			else {
				member.fill(groupContainerPopulator, getButtonFactory(), getDefaultButtonConfigurer(),
						Collections.EMPTY_LIST);
			}
		}
		groupContainerPopulator.onPopulated();
	}
219880
public void saveInheritContainer(
        final CmsInheritanceContainer inheritanceContainer,
        final CmsGroupContainerElementPanel groupContainerElement) {

        if (getGroupcontainer() != null) {
            CmsRpcAction<Map<String, CmsContainerElementData>> action = new CmsRpcAction<Map<String, CmsContainerElementData>>() {

                /**
                 * @see org.opencms.gwt.client.rpc.CmsRpcAction#execute()
                 */
                @Override
                public void execute() {

                    start(0, true);
                    getContainerpageService().saveInheritanceContainer(
                        CmsCoreProvider.get().getStructureId(),
                        getData().getDetailId(),
                        inheritanceContainer,
                        getPageState(),
                        getLocale(),
                        this);
                }

                /**
                 * @see org.opencms.gwt.client.rpc.CmsRpcAction#onResponse(java.lang.Object)
                 */
                @Override
                protected void onResponse(Map<String, CmsContainerElementData> result) {

                    stop(false);
                    m_elements.putAll(result);
                    try {
                        replaceContainerElement(groupContainerElement, result.get(groupContainerElement.getId()));
                    } catch (Exception e) {
                        CmsDebugLog.getInstance().printLine("Error replacing group container element");
                    }
                    addToRecentList(groupContainerElement.getId(), null);
                    CmsNotification.get().send(
                        Type.NORMAL,
                        Messages.get().key(Messages.GUI_NOTIFICATION_INHERITANCE_CONTAINER_SAVED_0));

                }
            };
            action.execute();

        }
    }
469134
@Override
    public CommandGroup createCommandGroup(String groupId, List<? extends AbstractCommand> members) {
		return createCommandGroup(groupId, members.toArray(), false, null);
	}
877045
async def create(gc: GroupControl, name, slaves):
    """"""
    click.echo("Creating group %s with slaves: %s" % (name, slaves))
    click.echo(await gc.create(name, slaves))
1069056
@Override
    public IEntityGroupStore newGroupStore(ComponentGroupServiceDescriptor svcDescriptor)
            throws GroupsException {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Creating New Grouper IEntityGroupStore");
        }
        return getGroupStore();
    }
132014
@Override
    public ContainerDef container(String name) {
        GroupContainerDefImpl contianer = new GroupContainerDefImpl(getDescriptorName(), getRootNode(), group,
            group.getOrCreate("container@qualifier=" + name));
        contianer.setContainerName(name);
        return contianer;
    }
372527
private PlexusContainer createContainer() throws PlexusContainerException {
    ContainerConfiguration config = new DefaultContainerConfiguration()
        .setClassWorld(classWorld.get())
        .setName("plexus-runtime");

    DefaultPlexusContainer container = new DefaultPlexusContainer(config);
    container.setLoggerManager(new Slf4jLoggerManager());
    container.getLoggerManager().setThresholds(Logger.LEVEL_DEBUG);

    return container;
  }
714468
public ApiResponse createGroup(String groupPath, String groupTitle) {
     return createGroup(groupPath, groupTitle, null);  
    }
1161812
protected void addAllGroupsToRole(Set<String> groups, String role) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, CLASS_NAME + "addAllGroupsToRole", new Object[] { groups, role });
        }
        Set<String> groupsForTheRole = roleToGroupMap.get(role);
        if (groupsForTheRole != null) {
            groupsForTheRole.addAll(groups);
        } else {
            groupsForTheRole = groups;
        }
        roleToGroupMap.put(role, groupsForTheRole);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, CLASS_NAME + "addAllGroupsToRole");
        }
    }
406818
private void storeGroup(final Group nextGroup, final RepositoryConnection conn, final boolean isRootGroup)
        throws RepositoryException
    {
        if(conn.hasStatement(null, SesameRealmConstants.OAS_GROUPNAME, this.vf.createLiteral(nextGroup.getName()),
                true, this.getContexts()))
        {
            // TODO: Create an update method
            throw new RuntimeException(
                    "A user with the given identifier already exists. Cannot add a new user with that identifier.");
        }
        
        final URI nextGroupUUID =
                this.vf.createURI("urn:oas:group:", nextGroup.getName() + ":" + UUID.randomUUID().toString());
        
        conn.add(this.vf.createStatement(nextGroupUUID, RDF.TYPE, SesameRealmConstants.OAS_GROUP), this.getContexts());
        
        if(isRootGroup)
        {
            conn.add(this.vf.createStatement(nextGroupUUID, RDF.TYPE, SesameRealmConstants.OAS_ROOTGROUP),
                    this.getContexts());
        }
        
        conn.add(
                this.vf.createStatement(nextGroupUUID, SesameRealmConstants.OAS_GROUPNAME,
                        this.vf.createLiteral(nextGroup.getName())), this.getContexts());
        conn.add(
                this.vf.createStatement(nextGroupUUID, SesameRealmConstants.OAS_GROUPDESCRIPTION,
                        this.vf.createLiteral(nextGroup.getDescription())), this.getContexts());
        conn.add(
                this.vf.createStatement(nextGroupUUID, SesameRealmConstants.OAS_GROUPINHERITINGROLES,
                        this.vf.createLiteral(nextGroup.isInheritingRoles())), this.getContexts());
        
        // only store users who cannot be found based on their identifier
        for(final User nextUser : nextGroup.getMemberUsers())
        {
            if(this.findUser(nextUser.getIdentifier()) == null)
            {
                final URI nextUserUri = this.addUser(nextUser);
            }
        }
        
        if(!nextGroup.getMemberGroups().isEmpty())
        {
            for(final Group nextMemberGroup : nextGroup.getMemberGroups())
            {
                // always set rootGroup parameter to false when recursing into member groups
                this.storeGroup(nextMemberGroup, conn, false);
            }
        }
        
    }
109665
private void populateContainer(FieldType field, List<Pair<String, String>> items)
   {
      CustomField config = m_container.getCustomField(field);
      CustomFieldLookupTable table = config.getLookupTable();

      for (Pair<String, String> pair : items)
      {
         CustomFieldValueItem item = new CustomFieldValueItem(Integer.valueOf(0));
         item.setValue(pair.getFirst());
         item.setDescription(pair.getSecond());
         table.add(item);
      }
   }
1003033
public PermutationGroup getAutomorphismGroup(IAtomContainer atomContainer, Partition initialPartition) {
        setup(atomContainer);
        super.refine(initialPartition);
        return super.getAutomorphismGroup();
    }
79436
public void startEditingGroupcontainer(
        final CmsGroupContainerElementPanel groupContainer,
        final boolean isElementGroup) {

        removeEditButtonsPositionTimer();
        I_CmsSimpleCallback<Boolean> callback = new I_CmsSimpleCallback<Boolean>() {

            public void execute(Boolean arg) {

                if (arg.booleanValue()) {
                    if (isElementGroup) {
                        m_groupEditor = CmsGroupContainerEditor.openGroupcontainerEditor(
                            groupContainer,
                            CmsContainerpageController.this,
                            m_handler);
                    } else {
                        m_groupEditor = CmsInheritanceContainerEditor.openInheritanceContainerEditor(
                            groupContainer,
                            CmsContainerpageController.this,
                            m_handler);
                    }
                } else {
                    CmsNotification.get().send(
                        Type.WARNING,
                        Messages.get().key(Messages.GUI_NOTIFICATION_UNABLE_TO_LOCK_0));
                }
            }
        };
        if ((m_groupEditor == null) && (groupContainer.isNew())) {
            callback.execute(Boolean.TRUE);
        } else {
            lockContainerpage(callback);
        }

    }
337212
@Override
    public List<ContainerDef> getGroupContainers() {
        List<ContainerDef> containers = new ArrayList<ContainerDef>();
        for (Node container : group.get("container")) {
            containers.add(new GroupContainerDefImpl(getDescriptorName(), getRootNode(), group, container));
        }
        return containers;
    }
1129086
public KeePassFileBuilder addTopGroups(Group... groups) {
        for (Group group : groups) {
            rootBuilder.addGroup(group);
        }

        return this;
    }
1057082
@Override
    public CommandGroup createCommandGroup(String groupId, Object[] members) {
		return createCommandGroup(groupId, members, false, null);
	}
636809
protected void saveGroupContainer(CmsObject cms, Element parent, CmsGroupContainerBean groupContainer)
    throws CmsException {

        parent.clearContent();
        Element groupContainerElem = parent.addElement(XmlNode.GroupContainers.name());

        groupContainerElem.addElement(XmlNode.Title.name()).addCDATA(groupContainer.getTitle());
        groupContainerElem.addElement(XmlNode.Description.name()).addCDATA(groupContainer.getDescription());

        for (String type : groupContainer.getTypes()) {
            groupContainerElem.addElement(XmlNode.Type.name()).addCDATA(type);
        }

        // the elements
        for (CmsContainerElementBean element : groupContainer.getElements()) {
            CmsResource res = cms.readResource(element.getId(), CmsResourceFilter.IGNORE_EXPIRATION);
            if (OpenCms.getResourceManager().getResourceType(res.getTypeId()).getTypeName().equals(
                CmsResourceTypeXmlContainerPage.GROUP_CONTAINER_TYPE_NAME)) {
                LOG.warn(Messages.get().container(Messages.LOG_WARN_ELEMENT_GROUP_INSIDE_ELEMENT_GROUP_0));
                continue;
            }
            Element elemElement = groupContainerElem.addElement(XmlNode.Element.name());

            // the element
            Element uriElem = elemElement.addElement(XmlNode.Uri.name());
            fillResource(cms, uriElem, res);

            // the properties
            Map<String, String> properties = element.getIndividualSettings();
            Map<String, CmsXmlContentProperty> propertiesConf = OpenCms.getADEManager().getElementSettings(cms, res);

            CmsXmlContentPropertyHelper.saveProperties(cms, elemElement, properties, propertiesConf);
        }
    }