public class MappedList<U, V> extends AbstractList<U> {
    private final List<V> list;
    private final Function<V, U> mapper;

    public MappedList(List<V> list, Function<V, U> mapper) {
        this.list = list;
        this.mapper = mapper;
    }

    @Override
    public U get(int index) {
        return mapper.apply(list.get(index));
    }

    @Override
    public int size() {
        return list.size();
    }

                return plugin;
            }
        });
    }

    static <T> List<T> map(List<T> list, Function<T, T> mapper) {
        List<T> newList = list;
        for (int i = 0; i < newList.size(); i++) {
            T oldT = newList.get(i);
            T newT = mapper.apply(oldT);
            if (newT != oldT) {
                if (newList == list) {
                    newList = new ArrayList<>(list);

        }
        return model;
    }

    private <T> List<T> map(List<T> resources, Function<T, T> mapper) {
        List<T> newResources = null;
        if (resources != null) {
            for (int i = 0; i < resources.size(); i++) {
                T resource = resources.get(i);
                T newResource = mapper.apply(resource);
                if (newResource != null) {
                    if (newResources == null) {

        super(parent);
        this.attrib = attrib;
    }

    @Override
    public int compareChildNodePointers(NodePointer pointer1, NodePointer pointer2) {
        // should never happen because attributes have no children
        return 0;
    }

    @Override
    public Object getValue() {
        return attrib.getValue();
    }

    @Override
    public Object getBaseValue() {

                VersionRange.createFromVersion("1.0"),
                "type",
                null,
                "system",
                "compile");

        // this one should never happen in practice...
        Artifact artifact5 = factory.createDependencyArtifact(
                "test-grp", "test-artifact-5", VersionRange.createFromVersion("1.0"), "type", null, "system", "system");

 * <p>
 * This class, while technically is not immutable, should be considered as such once set up. If not mutated, it is also
 * thread-safe. The mutation of this class instances should happen beforehand their use in session.
 */
public class MavenChainedWorkspaceReader implements MavenWorkspaceReader {

    protected List<WorkspaceReader> readers;
    protected WorkspaceRepository repository;

    /**

              </params>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>attach-artifact</goal>
            </goals>
            <configuration>
              <artifacts>

            if (longValue > Integer.MAX_VALUE) {
                return null;
            }
            return (int) longValue;
        } catch (NumberFormatException e) {
            // should never happen since checked isDigits(s) before
            return null;
        }
    }

    @Override
    public String toString() {
        return comparable.toString();
    }

            if (result.hasErrors()) {
                hasErrors = true;
            }
        }
        return new Result<>(hasErrors, (Iterable<T>) modelsList, problemsList);
    }

    // helper to determine if problems contain error
    private static boolean hasErrors(Iterable<? extends ModelProblem> problems) {
        for (ModelProblem input : problems) {
            if (input.getSeverity().equals(Severity.ERROR)

Throwables$State$2 { void Throwables$State$2(String, int); public Throwables$State processLine(String); } org/junit/internal/management/ReflectiveRuntimeMXB$Holder.class package org.junit.internal.management; final synchronized class ReflectiveRuntimeMXB$Holder { private static final reflect.Method getInputArgumentsMet; private void ReflectiveRuntimeMXB$Holder(); static void <clinit>(); } org/junit/internal/management/ThreadMXBean.class package org.junit.internal.management; public abstract interface ThreadMXBean...