For the given group name, return the module list, on which it is mapped.
Create a new list, if not found.

@param map Map to be searched for group name.
@param groupname Group name to search.
12939
SortedSet<ModuleElement> getModuleList(Map<String, SortedSet<ModuleElement>> map,
            String groupname) {
        return map.computeIfAbsent(groupname, g -> new TreeSet<>(configuration.utils.makeModuleComparator()));
    }
723803
@Override
    public synchronized ChainGroupData getChainGroup(String groupName) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getChainGroup: " + groupName);
        }
        if (null == groupName) {
            return null;
        }
        return this.chainGroups.get(groupName);
    }
936660
List<PackageDoc> getPkgList(Map<String,List<PackageDoc>> map, String groupname) {
        List<PackageDoc> list = map.get(groupname);
        if (list == null) {
            list = new ArrayList<PackageDoc>();
            map.put(groupname, list);
        }
        return list;
    }
683545
public void setGroupList(java.util.Collection<Group> groupList) {
        if (groupList == null) {
            this.groupList = null;
            return;
        }

        this.groupList = new java.util.ArrayList<Group>(groupList);
    }
752921
def get(map_name):
  """"""
  if isinstance(map_name, Map):
    return map_name

  # Get the list of maps. This isn't at module scope to avoid problems of maps
  # being defined after this module is imported.
  maps = get_maps()
  map_class = maps.get(map_name)
  if map_class:
    return map_class()
  raise NoMapException("Map doesn't exist: %s" % map_name)
868357
@Override
    public IEntityGroup find(String key) throws GroupsException {

        if (isTreeRefreshRequired()) {
            refreshTree();
        }

        log.debug("Invoking find() for key:  {}", key);

        // All of our groups (incl. ROOT_GROUP)
        // are indexed in the 'groups' map by key...
        return groupsTree.getGroups().get(key);
    }
843203
public void binding(Map map)
	{
		Map<String, Object> values = map;
		if(values==null) return ;
		for (Entry<String,Object> entry : values.entrySet())
		{
			this.binding(entry.getKey(), entry.getValue());
		}
		
	}
959882
public String group(String groupName) {
        int idx = groupIndex(groupName);
        if (idx < 0) {
          throw new IndexOutOfBoundsException("No group \"" + groupName + "\"");
        }
        return group(idx);
    }
1038828
public GroupedMap clear(String group) {
		group = StrUtil.nullToEmpty(group).trim();
		writeLock.lock();
		try {
			final LinkedHashMap<String, String> valueMap = this.get(group);
			if (MapUtil.isNotEmpty(valueMap)) {
				valueMap.clear();
			}
		} finally {
			writeLock.unlock();
		}
		return this;
	}
627511
public void addGroupBy(String fieldName)
    {
        if (fieldName != null)
        {
            _getGroupby().add(new FieldHelper(fieldName, false));
        }
    }
109155
@Override
	public void putAll(Map<? extends String, ? extends String> m) {
		this.groupedMap.putAll(DEFAULT_GROUP, m);
	}
1057082
@Override
    public CommandGroup createCommandGroup(String groupId, Object[] members) {
		return createCommandGroup(groupId, members, false, null);
	}
435105
public DocumentationBuilder apiListingsByResourceGroupName(Map<String, List<ApiListing>> apiListings) {
    nullToEmptyMultimap(apiListings).entrySet().stream().forEachOrdered(entry -> {
      List<ApiListing> list;
      if (this.apiListings.containsKey(entry.getKey())) {
        list = this.apiListings.get(entry.getKey());
        list.addAll(entry.getValue());
      } else {
        list = new ArrayList<>(entry.getValue());
        this.apiListings.put(entry.getKey(), list);
      }
      list.sort(byListingPosition());
    });
    return this;
  }
1033735
private static DecoratorMap group_map_(Map<String, PathMatcher> paths) {
        if (paths.isEmpty()) return concat();

        return new DecoratorMap() {
            @Override
            public Stream<Consumer<MutableContext>> map(Stream<Consumer<MutableContext>> in, Context ctx) {
                final Map<String, TimeSeriesValueSet> pathMapping = paths.entrySet().stream()
                        .collect(Collectors.toMap(Map.Entry::getKey,
                                pmEntry -> {
                                    return ctx.getTSData()
                                    .getCurrentCollection()
                                    .get(p -> pmEntry.getValue().match(p.getPath()), x -> true);
                                }));

                for (final Map.Entry<String, TimeSeriesValueSet> pm
                             : pathMapping.entrySet()) {
                    final String identifier = pm.getKey();
                    final List<Consumer<MutableContext>> applications = pm.getValue().stream()
                            .map(group -> {
                                Consumer<MutableContext> application = (nestedCtx) -> nestedCtx.putGroupAliasByName(identifier, group::getGroup);
                                return application;
                            })
                            .collect(Collectors.toList());

                    in = in.flatMap(inApplication -> applications.stream().map(inApplication::andThen));
                }
                return in;
            }
        };
    }
1186275
public synchronized JaxRsClientFactory addFeatureMap(Map<JaxRsFeatureGroup, Set<Feature>> map) {
        map.forEach((g, fs) -> fs.forEach(f -> addFeatureToGroup(g, f)));
        return this;
    }
963196
protected void parseGroupMap(Map<String,Object> groupMap, Map<String,String> resultMap, String prefix) {
        Object obj;
        for (String groupKey : groupMap.keySet()) {
            obj = groupMap.get(groupKey);
            String key = prefix == null ? groupKey : prefix + "." + groupKey;
            if (obj instanceof Map)
                parseGroupMap(loader.getMap(groupKey, groupMap), resultMap, key); // Parse inner map
            else
                resultMap.put(key, decryptValue(obj.toString())); // String, Boolean and List values
        }
    }
151279
public void map(final Group group, final Role role)
    {
        this.getRoleMappings().add(new RoleMapping(group, role));
    }