public class MappedCollection<U, V> extends AbstractCollection<U> {
    private final Collection<V> list;
    private final Function<V, U> mapper;

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

    @Override
    public Iterator<U> iterator() {
        Iterator<V> it = list.iterator();
        return new Iterator<U>() {

            // The root locator can be used very early during the setup of Maven,
            // even before the arguments from the command line are parsed.  Any exception
            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }

                return actualOsName.contains(FAMILY_OPENVMS);
            default:
                return actualOsName.contains(family.toLowerCase(Locale.US));
        }
    }

    /**
     * Helper method to determine the current OS family.
     *
     * @return name of current OS family.
     */
    private static String getOsFamily() {
        return Stream.of(
                        FAMILY_DOS,

        // So now we have an url of the form file://<path>

        // We want to eliminate any relative path nonsense and lock down the path so we
        // need to fully resolve it before any submodules use the path. This can happen
        // when you are using a custom settings.xml that contains a relative path entry
        // for the local repository setting.

        File localRepository = new File(url.substring("file://".length()));

     * coordinates.
     *
     * @param artifact the artifact to add or replace.
     * @deprecated Please use {@link MavenProjectHelper}
     * @throws DuplicateArtifactAttachmentException will never happen but leave it for backward compatibility
     */
    public void addAttachedArtifact(Artifact artifact) throws DuplicateArtifactAttachmentException {
        // if already there we remove it and add again

    final Map<Path, Holder> modelByPath = new ConcurrentHashMap<>();

    final Map<GAKey, Holder> modelByGA = new ConcurrentHashMap<>();

    public static class Holder {
        private volatile boolean set;
        private volatile Model model;

        Holder() {}

        Holder(Model model) {
            this.model = Objects.requireNonNull(model);

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();
    }

                Model model = findRawModel(from, gId, aId);
                if (model != null) {
                    context.modelByGA.put(new GAKey(gId, aId), new Holder(model));
                    context.modelByPath.put(model.getPomFile(), new Holder(model));
                }
                return model;
            }

            @Override
            public Model getRawModel(Path from, Path path) {

        }
        return clazz.cast(o);
    }

    static <U, V> List<V> map(Collection<U> list, Function<U, V> mapper) {
        return list.stream().map(mapper).collect(Collectors.toList());
    }

    <artifactId>child</artifactId>
    <packaging>jar</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>${codehaus.groupId}</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>