<code>repeated group Module = 101 { ... }</code>
773261
public java.util.List<? extends com.google.javascript.jscomp.FunctionInformationMap.ModuleOrBuilder> 
      getModuleOrBuilderList() {
    return module_;
  }
1313700
private static Circuit getCircuitGroups(String group, Collection<String> neighborGroups)
    {
        final Collection<String> set = new HashSet<>(neighborGroups);
        final Circuit circuit;
        if (set.size() > 1)
        {
            final Iterator<String> iterator = set.iterator();
            final String groupIn = iterator.next();
            final String groupOut = iterator.next();
            final CircuitType type = getCircuitType(group, neighborGroups);

            if (groupIn.equals(group))
            {
                circuit = new Circuit(type, group, groupOut);
            }
            else
            {
                circuit = new Circuit(type, group, groupIn);
            }
        }
        else
        {
            circuit = null;
        }
        return circuit;
    }
962232
public static boolean setStringsWithGroup(String groupName,Map<String, Object> keyValueMap){
		if(keyValueMap == null || keyValueMap.isEmpty())return false;
		String[] keysValues = new String[keyValueMap.size() * 2];
		int index = 0;
		for (String key : keyValueMap.keySet()) {
			if(keyValueMap.get(key) == null)continue;
			keysValues[index++] = key;
			keysValues[index++] = keyValueMap.get(key).toString();
		}
		try {			
			if(JedisProviderFactory.isCluster(groupName)){
				return JedisProviderFactory.getMultiKeyJedisClusterCommands(groupName).mset(keysValues).equals(RESP_OK);
			}else{
				return JedisProviderFactory.getMultiKeyCommands(groupName).mset(keysValues).equals(RESP_OK);
			}
		} finally {
			JedisProviderFactory.getJedisProvider(groupName).release();
		}
	}
1122431
public com.google.javascript.jscomp.FunctionInformationMap.Module getModule(int index) {
    return module_.get(index);
  }
1334650
def make_modules(self, groups, code_opts):
        """"""
        modules = []
        for raw_module, raw_funcs in groups:
            module = raw_module[0].strip().strip(string.punctuation)
            funcs = [func.strip() for func in raw_funcs]
            args = [self.database.query_args(func, raw=True)
                    for func in funcs]
            if self.generic:
                args = [arg if arg else ('VOID *', [])
                        for arg in args]
            else:
                args = [arg for arg in args if arg]
            if not args:
                logging.info(_('%s not found.'), module)
                continue
            logging.debug(module)
            module = ModuleSource(module, zip(funcs, args),
                                  code_opts)
            modules.append(module.c_source())
        return AttrsGetter(modules)
1102258
public static <K, V, R extends MutableMultimap<K, V>> MutableMultimap<K, V> groupBy(
            Iterable<V> iterable,
            Function<? super V, ? extends K> function,
            R concurrentMultimap,
            int batchSize,
            ForkJoinPool executor)
    {
        FJIterate.forEach(
                iterable,
                new PassThruProcedureFactory<Procedure<V>>(new MultimapPutProcedure<>(concurrentMultimap, function)),
                Combiners.<Procedure<V>>passThru(),
                batchSize,
                executor);
        return concurrentMultimap;
    }
1071068
public static SimpleModule getModule() {
        SimpleModule module = new SimpleModule();
        module.addSerializer(DateTime.class, new DateTimeSerializer());
        return module;
    }
926749
private void findConfigurationsRecursively(List<Integer> rGroupNumbers, List<List<Integer>> occurrences,
            List<Integer> occurIndexes, List<Integer[]> distributions, List<List<RGroup>> substitutes, int level,
            List<IAtomContainer> result) throws CDKException {

        if (level == rGroupNumbers.size()) {

            if (!checkIfThenConditionsMet(rGroupNumbers, distributions)) return;

            // Clone the root to get a scaffold to plug the substitutes into.
            IAtomContainer root = this.getRootStructure();
            IAtomContainer rootClone = null;
            try {
                rootClone = (IAtomContainer) root.clone();
            } catch (CloneNotSupportedException e) {
                //Abort with CDK exception
                throw new CDKException("clone() failed; could not perform R-group substitution.");
            }

            for (int rgpIdx = 0; rgpIdx < rGroupNumbers.size(); rgpIdx++) {

                int rNum = rGroupNumbers.get(rgpIdx);
                int pos = 0;

                List<RGroup> mapped = substitutes.get(rgpIdx);
                for (RGroup substitute : mapped) {
                    IAtom rAtom = this.getRgroupQueryAtoms(rNum).get(pos);
                    if (substitute != null) {

                        IAtomContainer rgrpClone = null;
                        try {
                            rgrpClone = (IAtomContainer) (substitute.getGroup().clone());
                        } catch (CloneNotSupportedException e) {
                            throw new CDKException("clone() failed; could not perform R-group substitution.");
                        }

                        //root cloned, substitute cloned. These now need to be attached to each other..
                        rootClone.add(rgrpClone);

                        Map<Integer, IBond> rAttachmentPoints = this.getRootAttachmentPoints().get(rAtom);
                        if (rAttachmentPoints != null) {
                            // Loop over attachment points of the R# atom
                            for (int apo = 0; apo < rAttachmentPoints.size(); apo++) {
                                IBond bond = rAttachmentPoints.get(apo + 1);
                                //Check how R# is attached to bond
                                int whichAtomInBond = 0;
                                if (bond.getEnd().equals(rAtom)) whichAtomInBond = 1;
                                IAtom subsAt = null;
                                if (apo == 0)
                                    subsAt = substitute.getFirstAttachmentPoint();
                                else
                                    subsAt = substitute.getSecondAttachmentPoint();

                                //Do substitution with the clones
                                IBond cloneBond = rootClone.getBond(getBondPosition(bond, root));
                                if (subsAt != null) {
                                    IAtom subsCloneAtom = rgrpClone.getAtom(getAtomPosition(subsAt,
                                            substitute.getGroup()));
                                    cloneBond.setAtom(subsCloneAtom, whichAtomInBond);
                                }
                            }
                        }

                        //Optional: shift substitutes 2D for easier visual checking
                        if (rAtom.getPoint2d() != null && substitute != null
                                && substitute.getFirstAttachmentPoint() != null
                                && substitute.getFirstAttachmentPoint().getPoint2d() != null) {
                            Point2d pointR = rAtom.getPoint2d();
                            Point2d pointC = substitute.getFirstAttachmentPoint().getPoint2d();
                            double xDiff = pointC.x - pointR.x;
                            double yDiff = pointC.y - pointR.y;
                            for (IAtom subAt : rgrpClone.atoms()) {
                                if (subAt.getPoint2d() != null) {
                                    subAt.getPoint2d().x -= xDiff;
                                    subAt.getPoint2d().y -= yDiff;
                                }
                            }
                        }
                    } else {
                        //Distribution flag is 0, this means the R# group will not be substituted.
                        //Any atom connected to this group should be given the defined RestH value.
                        IAtom discarded = rootClone.getAtom(getAtomPosition(rAtom, root));
                        for (IBond r0Bond : rootClone.bonds()) {
                            if (r0Bond.contains(discarded)) {
                                for (IAtom atInBond : r0Bond.atoms()) {
                                    atInBond.setProperty(CDKConstants.REST_H, this.getRGroupDefinitions().get(rNum)
                                            .isRestH());
                                }
                            }
                        }
                    }

                    pos++;
                }
            }

            //Remove R# remnants from the clone, bonds and atoms that may linger.
            boolean confHasRGroupBonds = true;
            while (confHasRGroupBonds) {
                for (IBond cloneBond : rootClone.bonds()) {
                    boolean removeBond = false;
                    if (cloneBond.getBegin() instanceof IPseudoAtom
                            && isValidRgroupQueryLabel(((IPseudoAtom) cloneBond.getBegin()).getLabel()))
                        removeBond = true;
                    else if (cloneBond.getEnd() instanceof IPseudoAtom
                            && isValidRgroupQueryLabel(((IPseudoAtom) cloneBond.getEnd()).getLabel()))
                        removeBond = true;

                    if (removeBond) {
                        rootClone.removeBond(cloneBond);
                        confHasRGroupBonds = true;
                        break;
                    }
                    confHasRGroupBonds = false;
                }
            }
            boolean confHasRGroupAtoms = true;
            while (confHasRGroupAtoms) {
                for (IAtom cloneAt : rootClone.atoms()) {
                    if (cloneAt instanceof IPseudoAtom)
                        if (isValidRgroupQueryLabel(((IPseudoAtom) cloneAt).getLabel())) {
                            rootClone.removeAtomOnly(cloneAt);
                            confHasRGroupAtoms = true;
                            break;
                        }
                    confHasRGroupAtoms = false;
                }
            }
            //Add to result list
            result.add(rootClone);

        } else {
            for (int idx = 0; idx < occurrences.get(level).size(); idx++) {
                occurIndexes.set(level, idx);
                //With an occurrence picked 0..n for this level's R-group, now find
                //all possible distributions (positional alternatives).
                int occurrence = occurrences.get(level).get(idx);
                int positions = this.getRgroupQueryAtoms(rGroupNumbers.get(level)).size();
                Integer[] candidate = new Integer[positions];
                for (int j = 0; j < candidate.length; j++) {
                    candidate[j] = 0;
                }
                List<Integer[]> rgrpDistributions = new ArrayList<Integer[]>();
                findDistributions(occurrence, candidate, rgrpDistributions, 0);

                for (Integer[] distribution : rgrpDistributions) {
                    distributions.set(level, distribution);

                    RGroup[] mapping = new RGroup[distribution.length];
                    List<List<RGroup>> mappedSubstitutes = new ArrayList<List<RGroup>>();
                    mapSubstitutes(this.getRGroupDefinitions().get(rGroupNumbers.get(level)), 0, distribution, mapping,
                            mappedSubstitutes);

                    for (List<RGroup> mappings : mappedSubstitutes) {
                        substitutes.set(level, mappings);
                        findConfigurationsRecursively(rGroupNumbers, occurrences, occurIndexes, distributions,
                                substitutes, level + 1, result);

                    }
                }
            }
        }
    }
921739
@Override
    public final void generate(final Module module, final Element element) {

        final DCModule dcModule = (DCModule) module;

        final String title = dcModule.getTitle();
        if (title != null) {
            element.addContent(generateSimpleElementList("title", dcModule.getTitles()));
        }

        final String creator = dcModule.getCreator();
        if (creator != null) {
            element.addContent(generateSimpleElementList("creator", dcModule.getCreators()));
        }

        final List<DCSubject> subjects = dcModule.getSubjects();
        for (final DCSubject dcSubject : subjects) {
            element.addContent(generateSubjectElement(dcSubject));
        }

        final String description = dcModule.getDescription();
        if (description != null) {
            element.addContent(generateSimpleElementList("description", dcModule.getDescriptions()));
        }

        final String publisher = dcModule.getPublisher();
        if (publisher != null) {
            element.addContent(generateSimpleElementList("publisher", dcModule.getPublishers()));
        }

        final List<String> contributors = dcModule.getContributors();
        if (contributors != null) {
            element.addContent(generateSimpleElementList("contributor", contributors));
        }

        final Date dcDate = dcModule.getDate();
        if (dcDate != null) {
            for (final Date date : dcModule.getDates()) {
                element.addContent(generateSimpleElement("date", DateParser.formatW3CDateTime(date, Locale.US)));
            }
        }

        final String type = dcModule.getType();
        if (type != null) {
            element.addContent(generateSimpleElementList("type", dcModule.getTypes()));
        }

        final String format = dcModule.getFormat();
        if (format != null) {
            element.addContent(generateSimpleElementList("format", dcModule.getFormats()));
        }

        final String identifier = dcModule.getIdentifier();
        if (identifier != null) {
            element.addContent(generateSimpleElementList("identifier", dcModule.getIdentifiers()));
        }

        final String source = dcModule.getSource();
        if (source != null) {
            element.addContent(generateSimpleElementList("source", dcModule.getSources()));
        }

        final String language = dcModule.getLanguage();
        if (language != null) {
            element.addContent(generateSimpleElementList("language", dcModule.getLanguages()));
        }

        final String relation = dcModule.getRelation();
        if (relation != null) {
            element.addContent(generateSimpleElementList("relation", dcModule.getRelations()));
        }

        final String coverage = dcModule.getCoverage();
        if (coverage != null) {
            element.addContent(generateSimpleElementList("coverage", dcModule.getCoverages()));
        }

        final String rights = dcModule.getRights();
        if (rights != null) {
            element.addContent(generateSimpleElementList("rights", dcModule.getRightsList()));
        }

    }
1239372
private <T> Set<ConstraintViolation<T>> validateGroups(final GwtValidationContext<T> context,
      final GroupValidator groupValidator, final GroupChain groupChain) {

    final Set<ConstraintViolation<T>> violations = new HashSet<>();

    final Collection<Group> allGroups = groupChain.getAllGroups();
    final Group[] allGroupsArray = allGroups.toArray(new Group[allGroups.size()]);
    groupValidator.validateGroups(context, violations, allGroupsArray);

    // handle sequences
    final Iterator<List<Group>> sequenceIterator = groupChain.getSequenceIterator();
    while (sequenceIterator.hasNext()) {
      final List<Group> sequence = sequenceIterator.next();
      for (final Group group : sequence) {
        final int numberOfViolations = violations.size();
        groupValidator.validateGroups(context, violations, group);
        if (violations.size() > numberOfViolations) {
          // stop processing when an error occurs
          break;
        }
      }
    }
    return violations;
  }
812858
private AbstractPlanNode indexAccessForGroupByExprs(SeqScanPlanNode root,
            IndexGroupByInfo gbInfo) {
        if (! root.isPersistentTableScan()) {
            // subquery and common tables are not handled
            return root;
        }

        String fromTableAlias = root.getTargetTableAlias();
        assert(fromTableAlias != null);

        List<ParsedColInfo> groupBys = m_parsedSelect.groupByColumns();
        Table targetTable = m_catalogDb.getTables().get(root.getTargetTableName());
        assert(targetTable != null);
        CatalogMap<Index> allIndexes = targetTable.getIndexes();

        List<Integer> maxCoveredGroupByColumns = new ArrayList<>();
        ArrayList<AbstractExpression> maxCoveredBindings = null;
        Index pickedUpIndex = null;
        boolean foundAllGroupByCoveredIndex = false;

        for (Index index : allIndexes) {
            if ( ! IndexType.isScannable(index.getType())) {
                continue;
            }

            if ( ! index.getPredicatejson().isEmpty()) {
                // do not try to look at Partial/Sparse index
                continue;
            }

            ArrayList<AbstractExpression> bindings = new ArrayList<>();
            List<Integer> coveredGroupByColumns = calculateGroupbyColumnsCovered(
                    index, fromTableAlias, bindings);

            if (coveredGroupByColumns.size() > maxCoveredGroupByColumns.size()) {
                maxCoveredGroupByColumns = coveredGroupByColumns;
                pickedUpIndex = index;
                maxCoveredBindings = bindings;

                if (maxCoveredGroupByColumns.size() == groupBys.size()) {
                    foundAllGroupByCoveredIndex = true;
                    break;
                }
            }
        }
        if (pickedUpIndex == null) {
            return root;
        }

        IndexScanPlanNode indexScanNode = new IndexScanPlanNode(
                root, null, pickedUpIndex, SortDirectionType.INVALID);
        indexScanNode.setForGroupingOnly();
        indexScanNode.setBindings(maxCoveredBindings);

        gbInfo.m_coveredGroupByColumns = maxCoveredGroupByColumns;
        gbInfo.m_canBeFullySerialized = foundAllGroupByCoveredIndex;
        return indexScanNode;
    }
933632
public static <K, V, R extends MutableMultimap<K, V>> MutableMultimap<K, V> groupBy(
            Iterable<V> iterable,
            Function<? super V, ? extends K> function,
            R concurrentMultimap)
    {
        return FJIterate.groupBy(iterable, function, concurrentMultimap, FJIterate.DEFAULT_MIN_FORK_SIZE);
    }
832717
public int getGroupForPrimary(long p) {
        p >>= 16;
        if(p < scriptStarts[1] || scriptStarts[scriptStarts.length - 1] <= p) {
            return -1;
        }
        int index = 1;
        while(p >= scriptStarts[index + 1]) { ++index; }
        for(int i = 0; i < numScripts; ++i) {
            if(scriptsIndex[i] == index) {
                return i;
            }
        }
        for(int i = 0; i < MAX_NUM_SPECIAL_REORDER_CODES; ++i) {
            if(scriptsIndex[numScripts + i] == index) {
                return Collator.ReorderCodes.FIRST + i;
            }
        }
        return -1;
    }
1158795
public void setModule(JSModule module) {
    // An input may only belong to one module.
    checkArgument(module == null || this.module == null || this.module == module);
    this.module = module;
  }
1349998
@GwtIncompatible("Unnecessary")
  private JsonFileSpec createJsonFileFromModule(JSModule module) throws IOException {
    compiler.resetAndIntitializeSourceMap();

    StringBuilder output = new StringBuilder();
    writeModuleOutput(output, module);

    JsonFileSpec jsonFile = new JsonFileSpec(output.toString(),
        getModuleOutputFileName(module));

    StringBuilder moduleSourceMap = new StringBuilder();

    compiler.getSourceMap().appendTo(moduleSourceMap,
        getModuleOutputFileName(module));

    jsonFile.setSourceMap(moduleSourceMap.toString());

    return jsonFile;
  }
905610
@Override
    public CommandGroup createCommandGroup(String groupId, Object[] members, CommandConfigurer configurer) {
		return createCommandGroup(groupId, members, false, configurer);
	}
975347
public static Module createModule(final String name,final String version){
        final Module module = new Module();

        module.setName(name);
        module.setVersion(version);
        module.setPromoted(false);

        return module;

    }