org.d2ab.collection.ChainingIterable Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sequence Show documentation
A lightweight alternative to Java 8 sequential Stream
The newest version!
/*
 * Copyright 2016 Daniel Skogquist Åborg
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.d2ab.collection;

import org.d2ab.iterator.ChainingIterator;
import org.d2ab.iterator.MappingIterator;

import java.util.Iterator;
import java.util.function.Function;

import static org.d2ab.collection.SizedIterable.SizeType.*;

public class ChainingIterable implements SizedIterable {
	private final Iterable> iterables;
	private final SizeType sizeType;

	public static  SizedIterable empty() {
		return new ChainingIterable<>(Iterables.empty());
	}

	@SafeVarargs
	public static  SizedIterable concat(Iterable... iterables) {
		return new ChainingIterable<>(Iterables.of(iterables));
	}

	public static  SizedIterable concat(Iterable> iterables) {
		return new ChainingIterable<>(iterables);
	}

	public static  SizedIterable flatten(Iterable containers,
	                                              Function> mapper) {
		return new ChainingIterable<>(() -> new MappingIterator<>(containers.iterator(), mapper));
	}

	private ChainingIterable(Iterable> iterables) {
		this.iterables = iterables;
		this.sizeType = Iterables.sizeType(iterables);
	}

	@Override
	public Iterator iterator() {
		return new ChainingIterator<>(iterables);
	}

	public int size() {
		if (sizeType == INFINITE)
			throw new UnsupportedOperationException();

		long size = 0;
		for (Iterable iterable : iterables)
			size += Iterables.size(iterable);

		if (size > Integer.MAX_VALUE)
			throw new IllegalStateException("size > Integer.MAX_VALUE: " + size);

		return (int) size;
	}

	@Override
	public SizeType sizeType() {
		if (sizeType == INFINITE)
			throw new UnsupportedOperationException();

		SizeType sizeType = this.sizeType != FIXED ? AVAILABLE : FIXED;

		for (Iterable iterable : iterables)
			sizeType = sizeType.concat(Iterables.sizeType(iterable));

		return sizeType;
	}

	public boolean isEmpty() {
		if (sizeType == INFINITE)
			throw new UnsupportedOperationException();

		for (Iterable iterable : iterables)
			if (!Iterables.isEmpty(iterable))
				return false;

		return true;
	}
}