获取MongoDB数据源<br>

@param setting 设定文件
@param groups 分组列表
@return MongoDB连接
963070
public static MongoDS getDS(Setting setting, String... groups) {
		final String key = setting.getSettingPath() + GROUP_SEPRATER + ArrayUtil.join(groups, GROUP_SEPRATER);
		MongoDS ds = dsMap.get(key);
		if (null == ds) {
			// 没有在池中加入之
			ds = new MongoDS(setting, groups);
			dsMap.put(key, ds);
		}

		return ds;
	}
471468
public static String[] toSortedArray(Set<String> groups) {
        //TODO: sort in another way than just alphabetically
        String[] sortedArray = groups.toArray(new String[groups.size()]);

        Arrays.sort(sortedArray);

        return sortedArray;
    }
926912
public Set<Entry<String, String>> entrySet(String group) {
		return this.groupedMap.entrySet(group);
	}
1175523
public Setting set(String group, String key, String value) {
		this.put(group, key, value);
		return this;
	}
262998
@JsonIgnore
    public Map<String, Set<String>> getGroupingSpecification() {
        Map<String, Set<String>> result = new LinkedHashMap<>();
        if (!StringUtils.isBlank(grouping)) {
            String[] groups = split(grouping, '|');
            for (String group : groups) {
                String[] groupSpec = split(group.trim(), '=');
                if (groupSpec.length != 2) throw new ExportRequestGroupingFormatException(grouping);
                String groupName = groupSpec[0].trim();
                result.put(
                        groupName,
                        Sets.newLinkedHashSet(
                                Arrays.asList(
                                        split(groupSpec[1].trim(), ',')
                                ).stream()
                                        .map(String::trim)
                                        .collect(Collectors.toList())
                        )
                );
            }
        }
        return result;
    }
61118
public static <T, K, R> Map<R, List<T>> toMapGroupBy( Stream<T> stream, Function<T, R> groupingFunction ) {
        return stream.collect(Collectors.groupingBy(groupingFunction));
        // to get a set: Collectors.groupingBy(groupingFunction, Collectors.toSet())
    }
1357728
public static List<Group> filterGroupsByDescription(List<Group> groups, String description) {
    return groups.stream()
        .filter(group -> !Strings.isNullOrEmpty(group.getDescription()))
        .filter(group -> containsIgnoreCase(group.getDescription(), description))
        .collect(Collectors.toList());
  }
188446
public MulticastConfig setGroup(String group) {
    try {
      InetAddress address = InetAddress.getByName(group);
      if (!address.isMulticastAddress()) {
        throw new ConfigurationException("Invalid multicast group " + group);
      }
      return setGroup(address);
    } catch (UnknownHostException e) {
      throw new ConfigurationException("Failed to locate multicast group", e);
    }
  }
517194
public List<String> getGroups(String... groups) {
        synchronized (Hdf5Archive.LOCK_OBJECT) {
            if (groups.length == 0)
                return getObjects(this.file, H5O_TYPE_GROUP);
            Group[] groupArray = openGroups(groups);
            List<String> ls = getObjects(groupArray[groupArray.length - 1], H5O_TYPE_GROUP);
            closeGroups(groupArray);
            return ls;
        }
    }
1192930
public Setting getSetting(String group) {
		final Setting setting = new Setting();
		setting.putAll(this.getMap(group));
		return setting;
	}
1309118
private function getGroupsCollection() {
        if ($this->aclGroupCollection === null) {
            try {
                $this->aclGroupCollection = $this->getMongoClient()->selectCollection(
                    $this->params['databaseName'],
                    'accesscontrolgroup'
                );
            } catch (MongoException $e) {
                throw new DatabaseException('Could not select collection', 500, $e);
            }
        }

        return $this->aclGroupCollection;
    }
756772
public LinkedHashSet<String> getValues(String group) {
		if (group == null) {
			group = StrUtil.EMPTY;
		}
		return super.get(group);
	}
1330391
public void setDBSubnetGroups(java.util.Collection<DBSubnetGroup> dBSubnetGroups) {
        if (dBSubnetGroups == null) {
            this.dBSubnetGroups = null;
            return;
        }

        this.dBSubnetGroups = new com.amazonaws.internal.SdkInternalList<DBSubnetGroup>(dBSubnetGroups);
    }
737045
@Deprecated
    public ListGroupsResult withGroups(java.util.Collection<Group> groups) {
        setGroups(groups);
        return this;
    }
404601
def groups(self):
        
        groups = defaultdict(list)
        for setting in self.all():
            groups[setting.group].append(setting)
        return dict(groups)
106783
public GroupResources groupResources() {
        if (groups.get() == null) {
            groups.compareAndSet(null, new GroupResourcesImpl(this));
        }
        return groups.get();
    }
757975
public Map<String, String> getMap(String group) {
		final LinkedHashMap<String, String> map = this.groupedMap.get(group);
		return (null != map) ? map : new LinkedHashMap<String, String>(0);
	}