/* (non-Javadoc)
@see cyclops2.monads.transformers.values.ListT#grouped(int)
322824
@Override
    public ListT<W,Vector<T>> grouped(final int groupSize) {

        return (ListT<W,Vector<T>>) FoldableTransformerSeq.super.grouped(groupSize);
    }
1335678
public void setGroupList(java.util.Collection<String> groupList) {
        if (groupList == null) {
            this.groupList = null;
            return;
        }

        this.groupList = new com.amazonaws.internal.SdkInternalList<String>(groupList);
    }
888694
public void setGroupedResourceCounts(java.util.Collection<GroupedResourceCount> groupedResourceCounts) {
        if (groupedResourceCounts == null) {
            this.groupedResourceCounts = null;
            return;
        }

        this.groupedResourceCounts = new com.amazonaws.internal.SdkInternalList<GroupedResourceCount>(groupedResourceCounts);
    }
305336
List getGroupby()
    {
        List result = _getGroupby();
        Iterator iter = getCriteria().iterator();
        Object crit;

        while (iter.hasNext())
        {
            crit = iter.next();
            if (crit instanceof Criteria)
            {
                result.addAll(((Criteria) crit).getGroupby());
            }
        }

        return result;
    }
1042615
def grouped_value=(avps)
      new_content = ''
      avps.each { |a| new_content += a.to_wire }
      @content = new_content
    end
523864
@Override
    public Iterator findMemberGroups(IEntityGroup eg) throws GroupsException {
        Map groups = new HashMap();
        IEntityGroup group = null;
        for (Iterator itr = findLocalMemberGroups(eg); itr.hasNext(); ) {
            group = (IEntityGroup) itr.next();
            groups.put(group.getKey(), group);
        }

        String[] memberGroupKeys = getGroupStore().findMemberGroupKeys(eg);
        for (int i = 0; i < memberGroupKeys.length; i++) {
            if (!groups.containsKey(memberGroupKeys[i])) {
                group = GroupService.findGroup(memberGroupKeys[i]);
                if (group != null) {
                    groups.put(group.getKey(), group);
                }
            }
        }
        return groups.values().iterator();
    }
1180387
private void addGroup(String key, Group object) {
    int fieldIndex = getIndex(key);
    this.schema.getType(fieldIndex).asGroupType();
    this.data[fieldIndex].add(object);
  }
281852
public void setGroups(java.util.Collection<Group> groups) {
        if (groups == null) {
            this.groups = null;
            return;
        }

        this.groups = new java.util.ArrayList<Group>(groups);
    }
32469
public static <T extends Extendable> List<T> sortAndGroup(final List<T> values, final Group[] groups, final Sort sort, final boolean ascending) {
        List<T> list = sort(values, sort, ascending);
        list = group(list, groups);
        return list;
    }
109855
public static <T, R> Map<R, List<T>> groupBy(Stream<T> stream,
            Function<T, R> classifier) {
        return stream.collect(groupingBy(classifier));
    }
1003232
public void group(TreeTableColumn<S, ?>... treeTableColumns) {
        try {
            lock.lock();
            // init groups map
            if (groupOrder.size() == 0) {
                groups = new HashMap<>();
            }
            try {
                if (originalRoot == null) {
                    originalRoot = getRoot();
                }
                for (TreeTableColumn<S, ?> treeTableColumn : treeTableColumns) {
                    if (groupOrder.contains(treeTableColumn)) {
                        continue;
                    }
                    groups = group(treeTableColumn, groups, null, (RecursiveTreeItem<S>) originalRoot);
                }
                groupOrder.addAll(treeTableColumns);
                // update table ui
                buildGroupedRoot(groups, null, 0);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } finally {
            lock.unlock();
        }
    }
795620
public java.util.List<GroupedResourceCount> getGroupedResourceCounts() {
        if (groupedResourceCounts == null) {
            groupedResourceCounts = new com.amazonaws.internal.SdkInternalList<GroupedResourceCount>();
        }
        return groupedResourceCounts;
    }
150160
public final static void addGroup(final GroupingNotation notation, final int position,
			final HELM2Notation helm2notation) {
		helm2notation.getListOfGroupings().add(position, notation);
	}
169059
@Override
	public final void reduce(Iterable<IN> values, Collector<OUT> out) throws Exception {
		for (Iterator<OUT> iter = reduceGroup(values); iter.hasNext(); ) {
			out.collect(iter.next());
		}
	}
375696
@VisibleForTesting
    Map<QName, List<String>> getGroups(final String value) {
        final Map<QName, List<String>> res = new HashMap<>();

        final StringBuilder buf = new StringBuilder();
        int previousEnd = 0;
        final Matcher m = groupPattern.matcher(value);
        while(m.find()) {
            buf.append(value.subSequence(previousEnd, m.start()));
            final String v = m.group(2);
            if (!v.trim().isEmpty()) {
                final QName k = QName.valueOf(m.group(1));
                if (res.containsKey(k)) {
                    final List<String> l = new ArrayList<>(res.get(k));
                    l.addAll(Arrays.asList(v.trim().split("\\s+")));
                    res.put(k, l);
                } else {
                    res.put(k, Arrays.asList(v.trim().split("\\s+")));
                }
            }
            previousEnd = m.end();
        }
        buf.append(value.substring(previousEnd));
        if (!buf.toString().trim().isEmpty()) {
            res.put(null, Arrays.asList(buf.toString().trim().split("\\s+")));
        }
        return res;
    }
791105
@Override
	public String put(String key, String value) {
		return this.groupedMap.put(DEFAULT_GROUP, key, value);
	}
195305
public final static <T> Stream<Seq<T>> groupedUntil(final Stream<T> stream, final Predicate<? super T> predicate) {
        return groupedWhile(stream, predicate.negate());
    }