• Home
• org.neo4j
• neo4j-collections
• 5.24.2
• source code
• Iterables.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.neo4j.internal.helpers.collection.Iterables Maven / Gradle / Ivy

/*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [https://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
package org.neo4j.internal.helpers.collection;

import static java.util.Objects.requireNonNull;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
import org.neo4j.function.Predicates;
import org.neo4j.function.ThrowingConsumer;
import org.neo4j.graphdb.Resource;
import org.neo4j.graphdb.ResourceIterable;
import org.neo4j.graphdb.ResourceIterator;
import org.neo4j.internal.helpers.Exceptions;

/**
 * Utility methods for processing iterables. Where possible, If the iterable implements
 * {@link Resource}, it will be {@link Resource#close() closed} when the processing
 * has been completed.
 */
public final class Iterables {
    private Iterables() {
        throw new AssertionError("no instance");
    }

    public static  Iterable empty() {
        return Collections.emptyList();
    }

    @SuppressWarnings("unchecked")
    public static  ResourceIterable emptyResourceIterable() {
        return (ResourceIterable) EmptyResourceIterable.EMPTY_RESOURCE_ITERABLE;
    }

    /**
     * Collect all the elements available in {@code iterable} and add them to the
     * provided {@code collection}.
     * 

     * If the {@code iterable} implements {@link Resource} it will be
     * {@link Resource#close() closed} in a {@code finally} block after all
     * the items have been added.
     *
     * @param collection the collection to add items to.
     * @param iterable the iterable from which items will be collected
     * @param  the type of elements in {@code iterable}.
     * @param  the type of the collection to add the items to.
     * @return the {@code collection} that has been updated.
     */
    public static > C addAll(C collection, Iterable iterable) {
        try {
            Iterator iterator = iterable.iterator();
            try {
                while (iterator.hasNext()) {
                    collection.add(iterator.next());
                }
            } finally {

                Iterators.tryCloseResource(iterator);
            }
        } finally {
            tryCloseResource(iterable);
        }

        return collection;
    }

    public static  Iterable filter(Predicate specification, Iterable i) {
        return new FilterIterable<>(i, specification);
    }

    public static  List reverse(List iterable) {
        List list = asList(iterable);
        Collections.reverse(list);
        return list;
    }

    public static  Iterable map(Function function, Iterable from) {
        return new MapIterable<>(from, function);
    }

    @SafeVarargs
    public static  Iterable iterable(C... items) {
        return Arrays.asList(items);
    }

    @SuppressWarnings("unchecked")
    public static  Iterable cast(Iterable iterable) {
        return (Iterable) iterable;
    }

    @SafeVarargs
    @SuppressWarnings("unchecked")
    public static  Iterable concat(Iterable... iterables) {
        return concat(Arrays.asList((Iterable[]) iterables));
    }

    public static  Iterable concat(final Iterable> iterables) {
        return new CombiningIterable<>(iterables);
    }

    public static  Iterable append(final C item, final Iterable iterable) {
        return () -> {
            final Iterator iterator = iterable.iterator();

            return new Iterator<>() {
                T last = item;

                @Override
                public boolean hasNext() {
                    return iterator.hasNext() || last != null;
                }

                @Override
                public T next() {
                    if (iterator.hasNext()) {
                        return iterator.next();
                    }
                    try {
                        return last;
                    } finally {
                        last = null;
                    }
                }

                @Override
                public void remove() {}
            };
        };
    }

    public static Object[] asArray(Iterable