com.cinchapi.common.collect.lazy.LazyTransformSet Maven / Gradle / Ivy
/*
* Copyright (c) 2013-2019 Cinchapi Inc.
*
* 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 com.cinchapi.common.collect.lazy;
import java.util.AbstractSet;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Optional;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Collector;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import com.cinchapi.common.base.ReadOnlyIterator;
import com.cinchapi.common.base.Verify;
/**
* A {@link LazyTransformSet} reads through to another {@link Set} and
* transforms its items on the fly.
*
* This {@link Set} allows just-in-time transformation and should be used to
* transform elements on the fly when said transformation is expensive. This is
* especially useful in {@link #stream() stream} operations that feature
* intermediate
* operations like {@link Stream#skip(long) skipping}.
*
*
* @author Jeff Nelson
*/
public class LazyTransformSet extends AbstractSet {
/**
* Return a {@link LazyTransformSet} that uses the {@code transformer} to
* transform the items in {@code from} on the fly.
*
* @param from
* @param transformer
* @return the {@link LazyTransformSet}
*/
public static LazyTransformSet of(Set from,
Function transformer) {
return new LazyTransformSet<>(from, transformer);
}
/**
* The original {@link Set} whose items will be transformed.
*/
private final Set from;
/**
* The transforming function.
*/
private final Function transformer;
/**
* Construct a new instance.
*
* @param from
* @param transformer
*/
private LazyTransformSet(Set from, Function transformer) {
this.from = from;
this.transformer = transformer;
}
@Override
public Iterator iterator() {
return new SkippableTransformIterator<>(from.iterator(), transformer);
}
@Override
public int size() {
return from.size();
}
@Override
public Spliterator spliterator() {
return Spliterators.spliterator(iterator(), size(), 0);
}
@SuppressWarnings("unchecked")
@Override
public Stream stream() {
Iterator source = iterator();
Spliterator spliterator = Spliterators.spliterator(source, size(),
0);
Stream stream = StreamSupport.stream(spliterator, false);
return new SkipTrackingStream<>(stream,
(SkippableTransformIterator) source);
}
/**
* A {@link TransformIterator} that skips transformations for an ad-hoc
* number of elements at the beginning.
*
* @author Jeff Nelson
*/
private static class SkippableTransformIterator
extends TransformIterator {
/**
* The number of elements to skip during the iteration.
*/
private long skip = 0;
/**
* The current iteration index.
*/
private long index = 0;
/**
* Construct a new instance.
*
* @param skip
* @param from
* @param transformer
*/
SkippableTransformIterator(Iterator from,
Function transformer) {
super(from, transformer);
}
@Override
public T next() {
F next = from.next();
T transformed;
if(index >= skip) {
transformed = transformer.apply(next);
}
else {
// Since the elements are being skipped, the assumption is that
// they won't be consume, so we don't care about the potential
// for an NPE.
transformed = null;
}
++index;
return transformed;
}
/**
* Note that the next {@code n} elements should be skipped and not
* transformed
*
* @param n
* @return this; for chaining
*/
public final SkippableTransformIterator skip(long n) {
Verify.that(n > -1);
skip += n;
return this;
}
}
/**
* A {@link Stream} that keeps track of the total number of elements that
* must be {@link #skip(long) skipped} in the underlying source
* {@link #iterator()}.
*
*
* @author Jeff Nelson
*/
private static class SkipTrackingStream implements Stream {
/**
* The {@link Stream} whose skips are being tracked.
*/
private final Stream stream;
/**
* The source {@link Iterator} that the {@link #stream} ultimately reads
* through to.
*/
private final SkippableTransformIterator source;
/**
* Construct a new instance.
*
* @param stream
* @param source
*/
SkipTrackingStream(Stream stream,
SkippableTransformIterator source) {
this.stream = stream;
this.source = source;
}
@Override
public boolean allMatch(Predicate predicate) {
return stream.allMatch(predicate);
}
@Override
public boolean anyMatch(Predicate predicate) {
return stream.anyMatch(predicate);
}
@Override
public void close() {
stream.close();
}
@Override
public R collect(Collector collector) {
return stream.collect(collector);
}
@Override
public R collect(Supplier supplier,
BiConsumer accumulator,
BiConsumer combiner) {
return stream.collect(supplier, accumulator, combiner);
}
@Override
public long count() {
return stream.count();
}
@Override
public Stream distinct() {
return stream.distinct();
}
@Override
public Stream filter(Predicate predicate) {
return stream.filter(predicate);
}
@Override
public Optional findAny() {
return stream.findAny();
}
@Override
public Optional findFirst() {
return stream.findFirst();
}
@Override
public Stream flatMap(
Function> mapper) {
return stream.flatMap(mapper);
}
@Override
public DoubleStream flatMapToDouble(
Function mapper) {
return stream.flatMapToDouble(mapper);
}
@Override
public IntStream flatMapToInt(
Function mapper) {
return stream.flatMapToInt(mapper);
}
@Override
public LongStream flatMapToLong(
Function mapper) {
return stream.flatMapToLong(mapper);
}
@Override
public void forEach(Consumer action) {
stream.forEach(action);
}
@Override
public void forEachOrdered(Consumer action) {
stream.forEachOrdered(action);
}
@Override
public boolean isParallel() {
return stream.isParallel();
}
@Override
public Iterator iterator() {
return stream.iterator();
}
@Override
public Stream limit(long maxSize) {
return stream.limit(maxSize);
}
@Override
public Stream map(Function mapper) {
return stream.map(mapper);
}
@Override
public DoubleStream mapToDouble(ToDoubleFunction mapper) {
return stream.mapToDouble(mapper);
}
@Override
public IntStream mapToInt(ToIntFunction mapper) {
return stream.mapToInt(mapper);
}
@Override
public LongStream mapToLong(ToLongFunction mapper) {
return stream.mapToLong(mapper);
}
@Override
public Optional max(Comparator comparator) {
return stream.max(comparator);
}
@Override
public Optional min(Comparator comparator) {
return stream.min(comparator);
}
@Override
public boolean noneMatch(Predicate predicate) {
return stream.noneMatch(predicate);
}
@Override
public Stream onClose(Runnable closeHandler) {
return stream.onClose(closeHandler);
}
@Override
public Stream parallel() {
return stream.parallel();
}
@Override
public Stream peek(Consumer action) {
return stream.peek(action);
}
@Override
public Optional reduce(BinaryOperator accumulator) {
return stream.reduce(accumulator);
}
@Override
public T reduce(T identity, BinaryOperator accumulator) {
return stream.reduce(identity, accumulator);
}
@Override
public U reduce(U identity, BiFunction accumulator,
BinaryOperator combiner) {
return stream.reduce(identity, accumulator, combiner);
}
@Override
public Stream sequential() {
return stream.sequential();
}
@Override
public Stream skip(long n) {
return new SkipTrackingStream<>(stream.skip(n), source.skip(n));
}
@Override
public Stream sorted() {
return stream.sorted();
}
@Override
public Stream sorted(Comparator comparator) {
return stream.sorted(comparator);
}
@Override
public Spliterator spliterator() {
return stream.spliterator();
}
@Override
public Object[] toArray() {
return stream.toArray();
}
@Override
public A[] toArray(IntFunction generator) {
return stream.toArray(generator);
}
@Override
public Stream unordered() {
return stream.unordered();
}
}
/**
* A {@link ReadOnlyIterator} that reads through and transforms elements
* from another {@link Iterator} on-the-fly.
*
* @author Jeff Nelson
*/
private static class TransformIterator extends ReadOnlyIterator {
/**
* An {@link Iterator} over the source elements.
*/
protected final Iterator from;
/**
* The transforming function
*/
protected final Function transformer;
/**
* Construct a new instance.
*
* @param from
* @param transformer
*/
TransformIterator(Iterator from, Function transformer) {
this.from = from;
this.transformer = transformer;
}
@Override
public final boolean hasNext() {
return from.hasNext();
}
@Override
public T next() {
F next = from.next();
return transformer.apply(next);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy