<code>repeated group Entry = 1 { ... }</code>
426615
public java.util.List<com.google.javascript.jscomp.FunctionInformationMap.Entry> getEntryList() {
    return entry_;
  }
241981
static DuplicateGroupedAndTyped countDuplicatesAndMaybeAddTypeInfoReturnObject(
      Iterable<?> itemsIterable, boolean addTypeInfo) {
    if (addTypeInfo) {
      Collection<?> items = iterableToCollection(itemsIterable);
      Optional<String> homogeneousTypeName = getHomogeneousTypeName(items);

      NonHashingMultiset<?> valuesWithCountsAndMaybeTypes =
          homogeneousTypeName.isPresent()
              ? countDuplicatesToMultiset(items)
              : countDuplicatesToMultiset(addTypeInfoToEveryItem(items));
      return new DuplicateGroupedAndTyped(valuesWithCountsAndMaybeTypes, homogeneousTypeName);
    } else {
      return new DuplicateGroupedAndTyped(
          countDuplicatesToMultiset(itemsIterable),
          /* homogeneousTypeToDisplay= */ Optional.<String>absent());
    }
  }
515432
public GroupedMap putAll(String group, Map<? extends String, ? extends String> m) {
		for (Entry<? extends String, ? extends String> entry : m.entrySet()) {
			this.put(group, entry.getKey(), entry.getValue());
		}
		return this;
	}
1127286
public int getNumberOfInputGroupVertices() {

		int retVal = 0;

		final Iterator<ManagementGroupVertex> it = this.groupVertices.iterator();
		while (it.hasNext()) {
			if (it.next().isInputVertex()) {
				++retVal;
			}
		}

		return retVal;
	}
950985
def remove_group(self, group):
        
        if not isinstance(group, Group):
            raise TypeError("group must be Group")
        if group not in self.groups:
            raise ValueError("Group doesn't exist / is not bound to this database.")
        
        #save num entries and children before removal to avoid for loop problems
        num_entries = len(group.entries)
        for i in xrange(num_entries):
            self.remove_entry(group.entries[0])

        # Recurse down to remove sub-groups
        num_children = len(group.children)
        for i in xrange(num_children): # We may need to copy this to avoid CME (see below)
            self.remove_group(group.children[0])
        
        # Finally remove group from the parent's list.
        group.parent.children.remove(group) # Concurrent modification exception? Parent in recursive stack is iterating ...
        self.groups.remove(group)
91484
@Pure
	public int getPointCountInGroup(int groupIndex) {
		if (groupIndex == 0 && this.pointCoordinates == null) {
			return 0;
		}
		final int firstInGroup = firstInGroup(groupIndex);
		final int lastInGroup = lastInGroup(groupIndex);
		return (lastInGroup - firstInGroup) / 2 + 1;
	}
958986
public synchronized Group getGroup(String groupName) {
    Group result = counters.get(groupName);
    if (result == null) {
      result = new Group(groupName);
      counters.put(groupName, result);
    }
    return result;
  }
452795
public long appendEntry(JournalEntry entry) {
    // TODO(gpang): handle bounding the queue if it becomes too large.

    /**
     * Protocol for appending entries
     *
     * This protocol is lock free, to reduce the overhead in critical sections. It uses
     * {@link AtomicLong} and {@link ConcurrentLinkedQueue} which are both lock-free.
     *
     * The invariant that must be satisfied is that the 'counter' that is returned must be
     * greater than or equal to the actual counter of the entry in the queue.
     *
     * In order to guarantee the invariant, the {@link #mCounter} is incremented before adding the
     * entry to the {@link #mQueue}. AFTER the counter is incremented, whenever the counter is
     * read, it is guaranteed to be greater than or equal to the counter for the queue entries.
     *
     * Therefore, the {@link #mCounter} must be read AFTER the entry is added to the queue. The
     * resulting read of the counter AFTER the entry is added is guaranteed to be greater than or
     * equal to the counter for the entries in the queue.
     */
    mCounter.incrementAndGet();
    mQueue.offer(entry);
    return mCounter.get();
  }
74428
public static boolean isValidRgroupQueryLabel(String Rxx) {
        Matcher matcher = validLabelPattern.matcher(Rxx);
        if (matcher.find()) {
            int groupNumber = Integer.valueOf(Rxx.substring(1));
            if (groupNumber >= 1 && groupNumber <= 32) {
                return true;
            }
        }
        return false;
    }
607412
private static List<Object> convertLogicalList(Group g, boolean binaryAsString)
  {
    /*
      // List<Integer> (nullable list, non-null elements)
      optional group my_list (LIST) {
        repeated int32 element;
      }

      // List<Tuple<String, Integer>> (nullable list, non-null elements)
      optional group my_list (LIST) {
        repeated group element {
          required binary str (UTF8);
          required int32 num;
        };
      }

      // List<OneTuple<String>> (nullable list, non-null elements)
      optional group my_list (LIST) {
        repeated group array {
          required binary str (UTF8);
        };
      }

      // List<OneTuple<String>> (nullable list, non-null elements)
      optional group my_list (LIST) {
        repeated group my_list_tuple {
          required binary str (UTF8);
        };
      }
     */
    assert isLogicalListType(g.getType());
    int repeated = g.getFieldRepetitionCount(0);
    boolean isListItemPrimitive = g.getType().getFields().get(0).isPrimitive();
    List<Object> vals = new ArrayList<>();

    for (int i = 0; i < repeated; i++) {
      if (isListItemPrimitive) {
        vals.add(convertPrimitiveField(g, 0, i, binaryAsString));
      } else {
        Group listItem = g.getGroup(0, i);
        vals.add(listItem);
      }
    }
    return vals;
  }
1037586
public void insertGroup(int inserted, @Nullable List<L> groups) {
        if (inserted < 0 || inserted >= mCards.size() || groups == null || groups.size() == 0)
            return;

        List<L> cards = getGroups();

        boolean changed = cards.addAll(inserted, groups);

        if (changed)
            setData(cards);
    }
979509
private synchronized void updateMetric(String value, Group group, Set<String>[] groupKeys, int index){
		group.update(value);
		if (index < groupKeys.length){
			for (String key : groupKeys[index]){
				Group subgroup = group.subgroup(key);
				updateMetric(value, subgroup, groupKeys, index + 1);
			}
		}
	}
306092
@Override
    public java.util.Iterator findMemberGroups(IEntityGroup group) throws GroupsException {
        String[] keys = findMemberGroupKeys(group); // No foreign groups here.
        List groups = new ArrayList(keys.length);
        for (int i = 0; i < keys.length; i++) {
            groups.add(find(keys[i]));
        }
        return groups.iterator();
    }
30660
@Override
    public void updateGroup(ILockableEntityGroup group, boolean renewLock) throws GroupsException {
        throwExceptionIfNotInternallyManaged();

        try {
            if (!group.getLock().isValid()) {
                throw new GroupsException(
                        "Could not update group " + group.getKey() + " has invalid lock.");
            }

            //      updateGroup((IEntityGroup)group);
            getGroupStore().update(group);
            if (cacheInUse()) {
                cacheRemove(group);
            }
            synchronizeGroupMembersOnUpdate(group);

            if (renewLock) {
                group.getLock().renew();
            } else {
                group.getLock().release();
            }

        } catch (LockingException le) {
            throw new GroupsException("Problem updating group " + group.getKey(), le);
        }
    }
933045
public void run() throws IllegalArgumentException {
        List<List<ResultEntry>> groups = null;

        for (int i = 0; i < this.repeatedRuns; ++i) {
            this.solver.getResult().clearResults();
            this.solver.run();
            Result result = this.solver.getResult();

            if (groups == null) {
                // create empty groups
                groups = new ArrayList<List<ResultEntry>>(result.getResultEntries().size());
                // allocate space in every group
                for (int j = 0; j < result.getResultEntries().size(); ++j) {
                    groups.add(new ArrayList<ResultEntry>(this.repeatedRuns));
                }
            }

            if (result.getResultEntries().size() != groups.size())
                throw new IllegalArgumentException(String.format(
                        "Wrapped solver must return result with identical number of elements each run, " +
                        "given %d in run %d, expected %d",
                        result.getResultEntries().size(), i, groups.size()));

            for (int j = 0; j < result.getResultEntries().size(); j++) {
                ResultEntry resultEntry = result.getResultEntries().get(j);

                groups.get(j).add(resultEntry);
            }
        }

        int middleIndex = this.repeatedRuns / 2;

        for (List<ResultEntry> group : groups) {
            Collections.sort(group, new ResultEntryFitnessComparator());

            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Sorted result entries, dump:");
                for (int i = 0; i < group.size(); i++) {
                    ResultEntry resultEntry = group.get(i);
                    this.logger.debug(i + ". " + resultEntry.getBestFitness());
                }
            }

            this.getResult().addEntry(group.get(middleIndex));
        }


        if (this.file != null) {
            try {
                PrintStream printStream = new PrintStream(file);
                for (List<ResultEntry> group : groups) {
                    printStream.printf("Sorted entries for %s/%s\n", group.get(0).getAlgorithm(), group.get(0).getProblem());
                    for (int i = 0; i < group.size(); i++) {
                        printStream.printf("%03d. %.5f\n", i, group.get(i).getBestFitness());
                    }
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
1180387
private void addGroup(String key, Group object) {
    int fieldIndex = getIndex(key);
    this.schema.getType(fieldIndex).asGroupType();
    this.data[fieldIndex].add(object);
  }
1122769
private Entry<K, V> getEntry(K key) {
        final K k = key;
        
        return new Entry<K, V>() {
            public boolean equals(Object ob) {
                if( ob instanceof Entry ) {
                    Entry entry = (Entry)ob;
                    
                    if( !entry.getKey().equals(getKey()) ) {
                        return false;
                    }
                    if( !entry.getValue().equals(getValue()) ) {
                        return false;
                    }
                    return true;
                }
                return false;
            }

            public K getKey() {
                return k;
            }

            public V getValue() {
                return ConcurrentCache.this.get(getKey());
            }

            public V setValue(V val) {
                return ConcurrentCache.this.put(getKey(), val);
            }
        };
    }