*/
    public MultiIterator(final Iterator<E>... iterators) {
        assertArgumentNotNull("iterators", iterators);
        this.iterators = iterators;
    }

    @Override
    public boolean hasNext() {
        for (; index < iterators.length; ++index) {
            if (iterators[index].hasNext()) {
                return true;
            }
        }
        return false;
    }

        assertArgumentNotNull("iterator", iterator);

        return () -> new IndexedIterator<>(iterator);
    }

    /**
     *
     * インスタンスを構築します。
     *
     * @param iterator
     *            イテレータ。{@literal null}であってはいけません
     */
    public IndexedIterator(final Iterator<T> iterator) {
        assertArgumentNotNull("iterator", iterator);

     */
    public IteratorEnumeration(final Iterator<T> iterator) {
        assertArgumentNotNull("iterator", iterator);
        this.iterator = iterator;
    }

    /**
     * {@link IteratorEnumeration}を作成します。
     *
     * @param iterable
     *            反復可能なオブジェクト。{@literal null}であってはいけません
     */
    public IteratorEnumeration(final Iterable<T> iterable) {
        assertArgumentNotNull("iterable", iterable);

            DependencyManagement target,
            DependencyManagement source,
            boolean sourceDominant,
            Map<Object, Object> context) {
        Iterator<Dependency> sourceIterator = source.getDependencies().iterator();
        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))

        assertNotNull(set);
        assertEquals(2, set.size());
        Iterator<Entry<String, String>> iterator = set.iterator();
        assertNotNull(iterator);
        assertTrue(iterator.hasNext());
        assertTrue(iterator.hasNext());
        Entry<String, String> entry = iterator.next();
        assertNotNull(entry);
        entry = iterator.next();
        assertNotNull(entry);

        return new AbstractSet<Entry<String, String>>() {
            @Override
            public Iterator<Entry<String, String>> iterator() {
                Iterator<Entry<Object, Object>> iterator = properties.entrySet().iterator();
                return new Iterator<Entry<String, String>>() {
                    Entry<String, String> next;

                    {
                        advance();

        this.list = list;
        this.mapper = mapper;
    }

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

            @Override
            public U next() {

    }

    private static boolean dependenciesEquals(List<Dependency> a, List<Dependency> b) {
        if (a.size() != b.size()) {
            return false;
        }

        Iterator<Dependency> aI = a.iterator();
        Iterator<Dependency> bI = b.iterator();

        while (aI.hasNext()) {
            Dependency aD = aI.next();
            Dependency bD = bI.next();

        this.result = result;
        this.artifacts = Collections.unmodifiableSet(artifacts);
    }

    @Override
    public Iterator<Artifact> iterator() {
        return artifacts.iterator();
    }

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

    @Override
    public DependencyResolutionResult getResult() {

            buffer.append(" among available goals ");
            List<MojoDescriptor> mojos = pluginDescriptor.getMojos();
            if (mojos != null) {
                for (Iterator<MojoDescriptor> it = mojos.iterator(); it.hasNext(); ) {
                    MojoDescriptor mojo = it.next();
                    if (mojo != null) {
                        buffer.append(mojo.getGoal());
                    }