Java Code Examples for org.gradle.util.CollectionUtils#sort()

private static <P, T> List<T> visitTasks(Visitor<P, T> visitor, ProjectAndTaskFilter filter, ProjectView project,
                                         int startingIndex, P userProjectObject, Comparator<TaskView> taskSorter) {
    List<T> taskObjects = new ArrayList<T>();
    List<TaskView> tasks = CollectionUtils.sort(project.getTasks(), taskSorter); //make a copy because we're going to sort them

    Iterator<TaskView> iterator = tasks.iterator();
    int index = startingIndex;
    while (iterator.hasNext()) {
        TaskView task = iterator.next();
        if (filter.doesAllowTask(task)) {
            T taskObject = visitor.visitTask(task, index, project, userProjectObject);
            taskObjects.add(taskObject);
        }
        index++;
    }

    return taskObjects;
}
 

private static <P, T> List<T> visitTasks(Visitor<P, T> visitor, ProjectAndTaskFilter filter, ProjectView project,
                                         int startingIndex, P userProjectObject, Comparator<TaskView> taskSorter) {
    List<T> taskObjects = new ArrayList<T>();
    List<TaskView> tasks = CollectionUtils.sort(project.getTasks(), taskSorter); //make a copy because we're going to sort them

    Iterator<TaskView> iterator = tasks.iterator();
    int index = startingIndex;
    while (iterator.hasNext()) {
        TaskView task = iterator.next();
        if (filter.doesAllowTask(task)) {
            T taskObject = visitor.visitTask(task, index, project, userProjectObject);
            taskObjects.add(taskObject);
        }
        index++;
    }

    return taskObjects;
}
 

public List<ModelPath> transform(final ModelPath unavailable) {
    Iterable<Suggestion> suggestions = Iterables.transform(availablePaths, new Function<ModelPath, Suggestion>() {
        public Suggestion apply(ModelPath available) {
            int distance = StringUtils.getLevenshteinDistance(unavailable.toString(), available.toString());
            boolean suggest = distance <= Math.min(3, unavailable.toString().length() / 2);
            if (suggest) {
                return new Suggestion(distance, available);
            } else {
                // avoid excess creation of Suggestion objects
                return null;
            }
        }
    });

    suggestions = Iterables.filter(suggestions, REMOVE_NULLS);
    List<Suggestion> sortedSuggestions = CollectionUtils.sort(suggestions);
    return CollectionUtils.collect(sortedSuggestions, Suggestion.EXTRACT_PATH);
}
 

private static <P, T> List<T> visitTasks(Visitor<P, T> visitor, ProjectAndTaskFilter filter, ProjectView project,
                                         int startingIndex, P userProjectObject, Comparator<TaskView> taskSorter) {
    List<T> taskObjects = new ArrayList<T>();
    List<TaskView> tasks = CollectionUtils.sort(project.getTasks(), taskSorter); //make a copy because we're going to sort them

    Iterator<TaskView> iterator = tasks.iterator();
    int index = startingIndex;
    while (iterator.hasNext()) {
        TaskView task = iterator.next();
        if (filter.doesAllowTask(task)) {
            T taskObject = visitor.visitTask(task, index, project, userProjectObject);
            taskObjects.add(taskObject);
        }
        index++;
    }

    return taskObjects;
}
 

public CompositeOperation<Operation> getProjectConfiguration() {
    List<Operation> operations = new ArrayList<Operation>();
    for (ProjectMetrics projectMetrics : projects.values()) {
        operations.add(projectMetrics.getConfigurationOperation());
    }
    operations = CollectionUtils.sort(operations, Operation.slowestFirst());
    return new CompositeOperation<Operation>(operations);
}
 

public CompositeOperation<Operation> getProjectConfiguration() {
    List<Operation> operations = new ArrayList<Operation>();
    for (ProjectProfile projectProfile : projects.values()) {
        operations.add(projectProfile.getConfigurationOperation());
    }
    operations = CollectionUtils.sort(operations, Operation.slowestFirst());
    return new CompositeOperation<Operation>(operations);
}
 

private static <P, T> List<P> visitProjects(Visitor<P, T> visitor, ProjectAndTaskFilter filter,
                                            List<ProjectView> sourceProjects, P parentProjectObject, Comparator<ProjectView> projectSorter, Comparator<TaskView> taskSorter) {
    List<P> projectObjects = new ArrayList<P>();

    sourceProjects = CollectionUtils.sort(sourceProjects, projectSorter);  //make a copy because we're going to sort them.

    Iterator<ProjectView> iterator = sourceProjects.iterator();
    int index = 0;
    while (iterator.hasNext()) {
        ProjectView project = iterator.next();

        if (filter.doesAllowProject(project)) {
            P userProjectObject = visitor.visitProject(project, index, parentProjectObject);
            projectObjects.add(userProjectObject);

            //visit sub projects
            List<P> subProjectObjects = visitProjects(visitor, filter, project.getSubProjects(), userProjectObject, projectSorter, taskSorter);

            //visit tasks. Notice that we pass in the number of subprojects as a starting index. This is so they'll come afterwards.
            List<T> taskObjects = visitTasks(visitor, filter, project, subProjectObjects.size(), userProjectObject, taskSorter);

            visitor.completedVisitingProject(userProjectObject, subProjectObjects, taskObjects);
        }
        index++;
    }

    return projectObjects;
}
 

public List<OptionDescriptor> getOptions(Object target) {
    final Class<?> targetClass = target.getClass();
    Map<String, OptionDescriptor> options = new HashMap<String, OptionDescriptor>();
    if (!cachedOptionElements.containsKey(targetClass)) {
        loadClassDescriptorInCache(target);
    }
    for (OptionElement optionElement : cachedOptionElements.get(targetClass)) {
        JavaMethod<Object, Collection> optionValueMethod = cachedOptionValueMethods.get(optionElement);
        options.put(optionElement.getOptionName(), new InstanceOptionDescriptor(target, optionElement, optionValueMethod));
    }
    return CollectionUtils.sort(options.values());
}
 

public <T extends Versioned> List<T> sort(Collection<T> versions) {
    return CollectionUtils.sort(versions, this);
}
 

/**
 * Returns the task executions for this project.
 */
public CompositeOperation<TaskExecution> getTasks() {
    List<TaskExecution> taskExecutions = CollectionUtils.sort(tasks.values(), Operation.slowestFirst());
    return new CompositeOperation<TaskExecution>(taskExecutions);
}
 

public CompositeOperation<ContinuousOperation> getDependencySets() {
    final List<ContinuousOperation> profiles = CollectionUtils.sort(dependencySets.values(), Operation.slowestFirst());
    return new CompositeOperation<ContinuousOperation>(profiles);
}
 

private List<Project> getChildren(Project project) {
    return CollectionUtils.sort(project.getChildProjects().values());
}
 

public CompositeOperation<ContinuousOperation> getDependencySets() {
    final List<ContinuousOperation> profiles = CollectionUtils.sort(dependencySets.values(), Operation.slowestFirst());
    return new CompositeOperation<ContinuousOperation>(profiles);
}
 

/**
 * Returns the task executions for this project.
 */
public CompositeOperation<TaskExecution> getTasks() {
    List<TaskExecution> taskExecutions = CollectionUtils.sort(tasks.values(), Operation.slowestFirst());
    return new CompositeOperation<TaskExecution>(taskExecutions);
}
 

public CompositeOperation<ContinuousOperation> getDependencySets() {
    final List<ContinuousOperation> profiles = CollectionUtils.sort(dependencySets.values(), Operation.slowestFirst());
    return new CompositeOperation<ContinuousOperation>(profiles);
}
 

public List<String> getSortedProjectNames() {
    return CollectionUtils.sort(projectNames);
}
 

/**
 * Returns the task executions for this project.
 */
public CompositeOperation<TaskExecution> getTasks() {
    List<TaskExecution> taskExecutions = CollectionUtils.sort(tasks.values(), Operation.slowestFirst());
    return new CompositeOperation<TaskExecution>(taskExecutions);
}
 

public List<String> getSortedProjectNames() {
    return CollectionUtils.sort(projectNames);
}
 

public AmbiguousBindingReporter(String referenceType, String referenceDescription, List<Provider> providers) {
    this.referenceType = referenceType;
    this.referenceDescription = referenceDescription;
    this.providers = CollectionUtils.sort(providers, PROVIDER_COMPARATOR);
}
 

/**
 * Get a list of the profiling containers for all projects
 * @return list
 */
public List<ProjectProfile> getProjects() {
    return CollectionUtils.sort(projects.values(), Operation.slowestFirst());
}