Update provided list of groups
@param groups      group list
@param groupConfig group config
@return OperationFuture wrapper for list of Group
348721
public OperationFuture<List<Group>> modify(List<Group> groups, GroupConfig groupConfig) {

        groups.stream()
            .forEach(group -> modify(group, groupConfig));

        return new OperationFuture<>(
            groups,
            new NoWaitingJobFuture()
        );
    }
535126
public OperationFuture<List<FirewallPolicy>> update(
            List<FirewallPolicy> firewallPolicyList,
            FirewallPolicyConfig config
    ) {
        firewallPolicyList.forEach(firewallPolicy -> update(firewallPolicy, config));

        return new OperationFuture<>(
            firewallPolicyList,
            new NoWaitingJobFuture()
        );
    }
1337281
public OperationFuture<List<Server>> stopMaintenance(Group... groups) {
        return serverService().stopMaintenance(
            getServerSearchCriteria(groups)
        );
    }
519484
public OperationFuture<List<Network>> update(List<Network> networkList, UpdateNetworkConfig config) {
        networkList.forEach(network -> update(network, config));

        return new OperationFuture<>(networkList, new NoWaitingJobFuture());
    }
458313
public OperationFuture<Network> update(Network network, UpdateNetworkConfig config) {
        NetworkMetadata networkMetadata = findByRef(network);

        networkClient.update(
            networkMetadata.getDataCenterId(),
            networkMetadata.getId(),
            new UpdateNetworkRequest()
                .name(config.getName())
                .description(config.getDescription())
        );

        return new OperationFuture<>(network, new NoWaitingJobFuture());
    }
1072053
public OperationFuture<Group> delete(Group group) {
        Link response = client.deleteGroup(idByRef(group));

        return new OperationFuture<>(
                group,
                response.getId(),
                queueClient
        );
    }
683545
public void setGroupList(java.util.Collection<Group> groupList) {
        if (groupList == null) {
            this.groupList = null;
            return;
        }

        this.groupList = new java.util.ArrayList<Group>(groupList);
    }
1130401
protected <T> long processUpdateGroup(Collection<T> coll, String groupType, String groupName, Collection<CpoWhere> wheres, Collection<CpoOrderBy> orderBy, Collection<CpoNativeFunction> nativeExpressions) throws CpoException {
    Connection c = null;
    long updateCount = 0;

    try {
      c = getWriteConnection();

      updateCount = processUpdateGroup(coll, groupType, groupName, wheres, orderBy, nativeExpressions, c);
      commitLocalConnection(c);
    } catch (Exception e) {
      // Any exception has to try to rollback the work;
      rollbackLocalConnection(c);
      ExceptionHelper.reThrowCpoException(e, "processUpdateGroup(Collection coll, String groupType, String groupName) failed");
    } finally {
      closeLocalConnection(c);
    }

    return updateCount;
  }
1192930
public Setting getSetting(String group) {
		final Setting setting = new Setting();
		setting.putAll(this.getMap(group));
		return setting;
	}
998594
public static synchronized void update(Map<String, Object> newConfig) {
        if (newConfig == null)
            throw new NullPointerException("Updated config must not be null");

        // Update the logging configuration
        LogProviderConfig config = loggingConfig.get();
        if (config != null) {
            config.update(newConfig);
            // Propagate updates to the delegate
            getDelegate().update(config);
        }
    }
731261
@Override
    public synchronized ChainGroupData updateChainGroup(String groupName, String[] chainNames) throws ChainGroupException, InvalidChainNameException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Updating chain group, " + groupName);
        }

        // Input parameters validated internally
        return addChainGroup(groupName, chainNames);
    }
202755
public OperationFuture<List<Group>> delete(Group... groups) {
        List<Group> groupList = Arrays.asList(groups);

        List<JobFuture> jobs = groupList.stream()
            .map(group -> delete(group).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            groupList,
            new ParallelJobsFuture(jobs)
        );
    }
569641
public OperationFuture<List<LoadBalancer>> update(
            LoadBalancerFilter loadBalancerFilter,
            LoadBalancerConfig config
    ) {
        checkNotNull(loadBalancerFilter, "Load balancer filter must be not null");

        List<LoadBalancer> loadBalancerList = findLazy(loadBalancerFilter)
                .map(metadata -> LoadBalancer.refById(
                    metadata.getId(),
                    DataCenter.refById(metadata.getDataCenterId())
                ))
                .collect(toList());

        return update(loadBalancerList, config);
    }
990131
@Override
    public void updateGroupMembers(IEntityGroup group) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        getGroupStore().updateMembers(group);
        if (cacheInUse()) {
            cacheUpdate(group);
        }
        synchronizeGroupMembersOnUpdate(group);
    }
875536
@Override
    public void addUsersAndGroupsToAllActions(Set<String> users, Set<String> groups) {
        Set<String> tempUsers = new HashSet<String>();
        Set<String> tempGroups = new HashSet<String>();
        tempUsers.addAll(users);
        tempGroups.addAll(groups);

        addAllUsersToRole(tempUsers, MessagingSecurityConstants.OPERATION_TYPE_SEND);
        addAllGroupsToRole(tempGroups, MessagingSecurityConstants.OPERATION_TYPE_SEND);

        addAllUsersToRole(tempUsers, MessagingSecurityConstants.OPERATION_TYPE_RECEIVE);
        addAllGroupsToRole(tempGroups, MessagingSecurityConstants.OPERATION_TYPE_RECEIVE);

    }
641349
public GroupsConfigurationBuilder withGroupers(List<Grouper<?>> groupers) {
      attributes.attribute(GROUPERS).set(groupers);
      return this;
   }
267683
function updateGroups() {
                        function createGroup(groupInfo, itemsContainer) {
                            var GroupType = (groupInfo.enableCellSpanning ?
                                Groups.CellSpanningGroup :
                                Groups.UniformGroup);
                            return new GroupType(that, itemsContainer);
                        }

                        var oldRealizedItemRange = (that._groups.length > 0 ?
                                that._getRealizationRange() :
                                null),
                            newGroups = [],
                            prepared = [],
                            cleanUpDom = {},
                            newGroupMap = {},
                            currentIndex = 0,
                            len = tree.length,
                            i;

                        for (i = 0; i < len; i++) {
                            var oldChangedRealizedRangeInGroup = null,
                                groupInfo = that._getGroupInfo(i),
                                groupKey = that._site.groupFromIndex(i).key,
                                oldGroup = that._groupMap[groupKey],
                                wasCellSpanning = oldGroup instanceof Groups.CellSpanningGroup,
                                isCellSpanning = groupInfo.enableCellSpanning;

                            if (oldGroup) {
                                if (wasCellSpanning !== isCellSpanning) {
                                    // The group has changed types so DOM needs to be cleaned up
                                    cleanUpDom[groupKey] = true;
                                } else {
                                    // Compute the range of changed items that is within the group's realized range
                                    var firstChangedIndexInGroup = Math.max(0, changedRange.firstIndex - oldGroup.startIndex),
                                        oldRealizedItemRangeInGroup = that._rangeForGroup(oldGroup, oldRealizedItemRange);
                                    if (oldRealizedItemRangeInGroup && firstChangedIndexInGroup <= oldRealizedItemRangeInGroup.lastIndex) {
                                        // The old changed realized range is non-empty
                                        oldChangedRealizedRangeInGroup = {
                                            firstIndex: Math.max(firstChangedIndexInGroup, oldRealizedItemRangeInGroup.firstIndex),
                                            lastIndex: oldRealizedItemRangeInGroup.lastIndex
                                        };
                                    }
                                }
                            }
                            var group = createGroup(groupInfo, tree[i].itemsContainer.element);
                            var prepareLayoutPromise;
                            if (group.prepareLayoutWithCopyOfTree) {
                                prepareLayoutPromise = group.prepareLayoutWithCopyOfTree(copyItemsContainerTree(tree[i].itemsContainer), oldChangedRealizedRangeInGroup, oldGroup, {
                                    groupInfo: groupInfo,
                                    startIndex: currentIndex,
                                });
                            } else {
                                prepareLayoutPromise = group.prepareLayout(getItemsContainerLength(tree[i].itemsContainer), oldChangedRealizedRangeInGroup, oldGroup, {
                                    groupInfo: groupInfo,
                                    startIndex: currentIndex,
                                });
                            }
                            prepared.push(prepareLayoutPromise);

                            currentIndex += group.count;

                            newGroups.push(group);
                            newGroupMap[groupKey] = group;
                        }

                        return Promise.join(prepared).then(function () {
                            var currentOffset = 0;
                            for (var i = 0, len = newGroups.length; i < len; i++) {
                                var group = newGroups[i];
                                group.offset = currentOffset;
                                currentOffset += that._getGroupSize(group);
                            }

                            // Clean up deleted groups
                            Object.keys(that._groupMap).forEach(function (deletedKey) {
                                var skipDomCleanUp = !cleanUpDom[deletedKey];
                                that._groupMap[deletedKey].cleanUp(skipDomCleanUp);
                            });

                            that._groups = newGroups;
                            that._groupMap = newGroupMap;
                        });
                    }