Specifies if the paths should be grouped by tags or stay as-is.

@param pathsGroupedBy the GroupBy enum
@return this builder
975114
public Swagger2MarkupConfigBuilder withPathsGroupedBy(GroupBy pathsGroupedBy) {
        Validate.notNull(pathsGroupedBy, "%s must not be null", "pathsGroupedBy");
        config.pathsGroupedBy = pathsGroupedBy;
        return this;
    }
1179305
public GetGroupResult withTags(java.util.Map<String, String> tags) {
        setTags(tags);
        return this;
    }
645163
public static List<String> applySpecialPaths(List<String> pathTokens) throws IllegalArgumentException {
        final ArrayList<String> newTokens = new ArrayList<String>();
        for (String pathToken : pathTokens) {
            if (isCurrentToken(pathToken)) { continue; } else if (isReverseToken(pathToken)) {
                final int size = newTokens.size();
                if (size == 0) {
                    throw VFSMessages.MESSAGES.onRootPath();
                }
                newTokens.remove(size - 1);
            } else { newTokens.add(pathToken); }
        }
        return newTokens;
    }
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;
  }
110977
public GroupOptions addGroupByQuery(Query query) {

		Assert.notNull(query, "Query for grouping must not be null.");
		groupByQuery.add(query);
		return this;
	}
364465
public void setGroupsForPath(Integer[] groups, int pathId) {
        String newGroups = Arrays.toString(groups);
        newGroups = newGroups.substring(1, newGroups.length() - 1).replaceAll("\\s", "");

        logger.info("adding groups={}, to pathId={}", newGroups, pathId);
        EditService.updatePathTable(Constants.PATH_PROFILE_GROUP_IDS, newGroups, pathId);
    }
641349
public GroupsConfigurationBuilder withGroupers(List<Grouper<?>> groupers) {
      attributes.attribute(GROUPERS).set(groupers);
      return this;
   }
717741
public GroupOptions addGroupByField(String fieldName) {

		Assert.hasText(fieldName, "Field.name for grouping must not be null/empty.");
		groupByFields.add(new SimpleField(fieldName));
		return this;
	}
18729
public static void setGroup(FileSystem fs, Path path, String group) throws IOException {
    fs.setOwner(path, fs.getFileStatus(path).getOwner(), group);
  }
1307866
public void setGroups(java.util.Collection<GroupMetadata> groups) {
        if (groups == null) {
            this.groups = null;
            return;
        }

        this.groups = new java.util.ArrayList<GroupMetadata>(groups);
    }
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())
    }
1328886
private void setTag(final int i, final String name, final String value, 
      final boolean groupby) {
    setTagName(i, name);
    setTagValue(i, value);
    isTagGroupby(i, groupby);
  }
371397
public static <T extends Extendable> List<T> group(final List<T> values, final Group[] groups) {
        final SortableList<T> list = getSortableList(values);
        final GroupStrategy strategy = new GroupStrategy();
        for (int i = groups.length - 1; i >= 0; i--) {
            list.sortOnProperty(groups[i], true, strategy);
        }
        return list;
    }
558625
public UrlStringBuilder setPath(String... elements) {
        Validate.noNullElements(elements, "elements cannot be null");

        this.path.clear();
        this.addPath(elements);
        return this;
    }
548346
public void setGroups(java.util.Collection<GroupInformation> groups) {
        if (groups == null) {
            this.groups = null;
            return;
        }

        this.groups = new java.util.ArrayList<GroupInformation>(groups);
    }
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();
        }
    }
118607
public UrlStringBuilder addPath(String... elements) {
        Validate.noNullElements(elements, "elements cannot be null");

        for (final String element : elements) {
            this.path.add(element);
        }
        return this;
    }