From 459ce8b5d21f28f69dd5e148161d614899febbab Mon Sep 17 00:00:00 2001 From: Markus Kreusch Date: Thu, 14 Jan 2016 21:47:27 +0100 Subject: [PATCH] Completed implementation of AutoClosingStream --- .../streams/AutoClosingDoubleStream.java | 188 ++++++++++++++++++ .../common/streams/AutoClosingIntStream.java | 179 +++++++++++++++++ .../common/streams/AutoClosingLongStream.java | 179 +++++++++++++++++ .../{ => streams}/AutoClosingStream.java | 9 +- .../streams/AutoClosingStreamFactory.java | 51 +++++ .../streams/DelegatingDoubleStream.java | 179 +++++++++++++++++ .../common/streams/DelegatingIntStream.java | 188 ++++++++++++++++++ .../common/streams/DelegatingLongStream.java | 184 +++++++++++++++++ .../{ => streams}/DelegatingStream.java | 58 ++---- .../streams/DelegatingStreamFactory.java | 51 +++++ .../{ => streams}/AutoClosingStreamTest.java | 3 +- .../filesystem/nio/DefaultNioAccess.java | 5 - .../cryptomator/filesystem/nio/NioFolder.java | 2 +- .../filesystem/nio/NioFolderTest.java | 2 +- 14 files changed, 1230 insertions(+), 48 deletions(-) create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java rename main/commons/src/main/java/org/cryptomator/common/{ => streams}/AutoClosingStream.java (92%) create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java rename main/commons/src/main/java/org/cryptomator/common/{ => streams}/DelegatingStream.java (77%) create mode 100644 main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java rename main/commons/src/test/java/org/cryptomator/common/{ => streams}/AutoClosingStreamTest.java (93%) diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java new file mode 100644 index 000000000..ec0a98b6b --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingDoubleStream.java @@ -0,0 +1,188 @@ +package org.cryptomator.common.streams; + +import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; + +import java.util.DoubleSummaryStatistics; +import java.util.OptionalDouble; +import java.util.function.BiConsumer; +import java.util.function.DoubleBinaryOperator; +import java.util.function.DoubleConsumer; +import java.util.function.DoublePredicate; +import java.util.function.ObjDoubleConsumer; +import java.util.function.Supplier; +import java.util.stream.DoubleStream; +import java.util.stream.Stream; + +public class AutoClosingDoubleStream extends DelegatingDoubleStream { + + public static DoubleStream from(DoubleStream delegate) { + return new AutoClosingDoubleStream(delegate); + } + + public AutoClosingDoubleStream(DoubleStream delegate) { + super(delegate, AUTO_CLOSING_STREAM_FACTORY); + } + + @Override + public void forEach(DoubleConsumer action) { + try { + super.forEach(action); + } finally { + close(); + } + } + + @Override + public void forEachOrdered(DoubleConsumer action) { + try { + super.forEachOrdered(action); + } finally { + close(); + } + } + + @Override + public double[] toArray() { + try { + return super.toArray(); + } finally { + close(); + } + } + + @Override + public double reduce(double identity, DoubleBinaryOperator op) { + try { + return super.reduce(identity, op); + } finally { + close(); + } + } + + @Override + public OptionalDouble reduce(DoubleBinaryOperator op) { + try { + return super.reduce(op); + } finally { + close(); + } + } + + @Override + public R collect(Supplier supplier, ObjDoubleConsumer accumulator, BiConsumer combiner) { + try { + return super.collect(supplier, accumulator, combiner); + } finally { + close(); + } + } + + @Override + public double sum() { + try { + return super.sum(); + } finally { + close(); + } + } + + @Override + public OptionalDouble min() { + try { + return super.min(); + } finally { + close(); + } + } + + @Override + public OptionalDouble max() { + try { + return super.max(); + } finally { + close(); + } + } + + @Override + public long count() { + try { + return super.count(); + } finally { + close(); + } + } + + @Override + public OptionalDouble average() { + try { + return super.average(); + } finally { + close(); + } + } + + @Override + public DoubleSummaryStatistics summaryStatistics() { + try { + return super.summaryStatistics(); + } finally { + close(); + } + } + + @Override + public boolean anyMatch(DoublePredicate predicate) { + try { + return super.anyMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean allMatch(DoublePredicate predicate) { + try { + return super.allMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean noneMatch(DoublePredicate predicate) { + try { + return super.noneMatch(predicate); + } finally { + close(); + } + } + + @Override + public OptionalDouble findFirst() { + try { + return super.findFirst(); + } finally { + close(); + } + } + + @Override + public OptionalDouble findAny() { + try { + return super.findAny(); + } finally { + close(); + } + } + + @Override + public Stream boxed() { + try { + return super.boxed(); + } finally { + close(); + } + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java new file mode 100644 index 000000000..dc3251574 --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingIntStream.java @@ -0,0 +1,179 @@ +package org.cryptomator.common.streams; + +import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; + +import java.util.IntSummaryStatistics; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.BiConsumer; +import java.util.function.IntBinaryOperator; +import java.util.function.IntConsumer; +import java.util.function.IntPredicate; +import java.util.function.ObjIntConsumer; +import java.util.function.Supplier; +import java.util.stream.IntStream; + +public class AutoClosingIntStream extends DelegatingIntStream { + + public static IntStream from(IntStream delegate) { + return new AutoClosingIntStream(delegate); + } + + public AutoClosingIntStream(IntStream delegate) { + super(delegate, AUTO_CLOSING_STREAM_FACTORY); + } + + @Override + public void forEach(IntConsumer action) { + try { + super.forEach(action); + } finally { + close(); + } + } + + @Override + public void forEachOrdered(IntConsumer action) { + try { + super.forEachOrdered(action); + } finally { + close(); + } + } + + @Override + public int[] toArray() { + try { + return super.toArray(); + } finally { + close(); + } + } + + @Override + public int reduce(int identity, IntBinaryOperator op) { + try { + return super.reduce(identity, op); + } finally { + close(); + } + } + + @Override + public OptionalInt reduce(IntBinaryOperator op) { + try { + return super.reduce(op); + } finally { + close(); + } + } + + @Override + public R collect(Supplier supplier, ObjIntConsumer accumulator, BiConsumer combiner) { + try { + return super.collect(supplier, accumulator, combiner); + } finally { + close(); + } + } + + @Override + public int sum() { + try { + return super.sum(); + } finally { + close(); + } + } + + @Override + public OptionalInt min() { + try { + return super.min(); + } finally { + close(); + } + } + + @Override + public OptionalInt max() { + try { + return super.max(); + } finally { + close(); + } + } + + @Override + public long count() { + try { + return super.count(); + } finally { + close(); + } + } + + @Override + public OptionalDouble average() { + try { + return super.average(); + } finally { + close(); + } + } + + @Override + public IntSummaryStatistics summaryStatistics() { + try { + return super.summaryStatistics(); + } finally { + close(); + } + } + + @Override + public boolean anyMatch(IntPredicate predicate) { + try { + return super.anyMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean allMatch(IntPredicate predicate) { + try { + return super.allMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean noneMatch(IntPredicate predicate) { + try { + return super.noneMatch(predicate); + } finally { + close(); + } + } + + @Override + public OptionalInt findFirst() { + try { + return super.findFirst(); + } finally { + close(); + } + } + + @Override + public OptionalInt findAny() { + try { + return super.findAny(); + } finally { + close(); + } + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java new file mode 100644 index 000000000..4bfc032de --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingLongStream.java @@ -0,0 +1,179 @@ +package org.cryptomator.common.streams; + +import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; + +import java.util.LongSummaryStatistics; +import java.util.OptionalDouble; +import java.util.OptionalLong; +import java.util.function.BiConsumer; +import java.util.function.LongBinaryOperator; +import java.util.function.LongConsumer; +import java.util.function.LongPredicate; +import java.util.function.ObjLongConsumer; +import java.util.function.Supplier; +import java.util.stream.LongStream; + +public class AutoClosingLongStream extends DelegatingLongStream { + + public static LongStream from(LongStream delegate) { + return new AutoClosingLongStream(delegate); + } + + public AutoClosingLongStream(LongStream delegate) { + super(delegate, AUTO_CLOSING_STREAM_FACTORY); + } + + @Override + public void forEach(LongConsumer action) { + try { + super.forEach(action); + } finally { + close(); + } + } + + @Override + public void forEachOrdered(LongConsumer action) { + try { + super.forEachOrdered(action); + } finally { + close(); + } + } + + @Override + public long[] toArray() { + try { + return super.toArray(); + } finally { + close(); + } + } + + @Override + public long reduce(long identity, LongBinaryOperator op) { + try { + return super.reduce(identity, op); + } finally { + close(); + } + } + + @Override + public OptionalLong reduce(LongBinaryOperator op) { + try { + return super.reduce(op); + } finally { + close(); + } + } + + @Override + public R collect(Supplier supplier, ObjLongConsumer accumulator, BiConsumer combiner) { + try { + return super.collect(supplier, accumulator, combiner); + } finally { + close(); + } + } + + @Override + public long sum() { + try { + return super.sum(); + } finally { + close(); + } + } + + @Override + public OptionalLong min() { + try { + return super.min(); + } finally { + close(); + } + } + + @Override + public OptionalLong max() { + try { + return super.max(); + } finally { + close(); + } + } + + @Override + public long count() { + try { + return super.count(); + } finally { + close(); + } + } + + @Override + public OptionalDouble average() { + try { + return super.average(); + } finally { + close(); + } + } + + @Override + public LongSummaryStatistics summaryStatistics() { + try { + return super.summaryStatistics(); + } finally { + close(); + } + } + + @Override + public boolean anyMatch(LongPredicate predicate) { + try { + return super.anyMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean allMatch(LongPredicate predicate) { + try { + return super.allMatch(predicate); + } finally { + close(); + } + } + + @Override + public boolean noneMatch(LongPredicate predicate) { + try { + return super.noneMatch(predicate); + } finally { + close(); + } + } + + @Override + public OptionalLong findFirst() { + try { + return super.findFirst(); + } finally { + close(); + } + } + + @Override + public OptionalLong findAny() { + try { + return super.findAny(); + } finally { + close(); + } + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/AutoClosingStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java similarity index 92% rename from main/commons/src/main/java/org/cryptomator/common/AutoClosingStream.java rename to main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java index 02207009a..01237ab10 100644 --- a/main/commons/src/main/java/org/cryptomator/common/AutoClosingStream.java +++ b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStream.java @@ -1,4 +1,6 @@ -package org.cryptomator.common; +package org.cryptomator.common.streams; + +import static org.cryptomator.common.streams.AutoClosingStreamFactory.AUTO_CLOSING_STREAM_FACTORY; import java.util.Comparator; import java.util.Optional; @@ -23,15 +25,14 @@ import java.util.stream.Stream; * * @author Markus Kreusch */ -public final class AutoClosingStream extends DelegatingStream { +public class AutoClosingStream extends DelegatingStream { public static Stream from(Stream delegate) { return new AutoClosingStream<>(delegate); } - @SuppressWarnings("unchecked") private AutoClosingStream(Stream delegate) { - super(delegate, AutoClosingStream::new); + super(delegate, AUTO_CLOSING_STREAM_FACTORY); } public void forEach(Consumer action) { diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java new file mode 100644 index 000000000..18b8ab4d8 --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/AutoClosingStreamFactory.java @@ -0,0 +1,51 @@ +package org.cryptomator.common.streams; + +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +class AutoClosingStreamFactory implements DelegatingStreamFactory { + + public static final DelegatingStreamFactory AUTO_CLOSING_STREAM_FACTORY = new AutoClosingStreamFactory(); + + private AutoClosingStreamFactory() { + } + + @Override + public Stream from(Stream other) { + if (AutoClosingStream.class.isInstance(other)) { + return other; + } else { + return AutoClosingStream.from(other); + } + } + + @Override + public IntStream from(IntStream other) { + if (AutoClosingIntStream.class.isInstance(other)) { + return other; + } else { + return AutoClosingIntStream.from(other); + } + } + + @Override + public LongStream from(LongStream other) { + if (AutoClosingLongStream.class.isInstance(other)) { + return other; + } else { + return AutoClosingLongStream.from(other); + } + } + + @Override + public DoubleStream from(DoubleStream other) { + if (AutoClosingDoubleStream.class.isInstance(other)) { + return other; + } else { + return AutoClosingDoubleStream.from(other); + } + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java new file mode 100644 index 000000000..8fca0e7fd --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingDoubleStream.java @@ -0,0 +1,179 @@ +package org.cryptomator.common.streams; + +import java.util.DoubleSummaryStatistics; +import java.util.OptionalDouble; +import java.util.PrimitiveIterator.OfDouble; +import java.util.function.BiConsumer; +import java.util.function.DoubleBinaryOperator; +import java.util.function.DoubleConsumer; +import java.util.function.DoubleFunction; +import java.util.function.DoublePredicate; +import java.util.function.DoubleToIntFunction; +import java.util.function.DoubleToLongFunction; +import java.util.function.DoubleUnaryOperator; +import java.util.function.ObjDoubleConsumer; +import java.util.function.Supplier; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +abstract class DelegatingDoubleStream implements DoubleStream { + + private final DoubleStream delegate; + private final DelegatingStreamFactory wrapper; + + public DelegatingDoubleStream(DoubleStream delegate, DelegatingStreamFactory wrapper) { + this.delegate = delegate; + this.wrapper = wrapper; + } + + public DoubleStream filter(DoublePredicate predicate) { + return wrapper.from(delegate.filter(predicate)); + } + + public boolean isParallel() { + return delegate.isParallel(); + } + + public DoubleStream map(DoubleUnaryOperator mapper) { + return wrapper.from(delegate.map(mapper)); + } + + public Stream mapToObj(DoubleFunction mapper) { + return wrapper.from(delegate.mapToObj(mapper)); + } + + public DoubleStream unordered() { + return wrapper.from(delegate.unordered()); + } + + public DoubleStream onClose(Runnable closeHandler) { + return wrapper.from(delegate.onClose(closeHandler)); + } + + public IntStream mapToInt(DoubleToIntFunction mapper) { + return wrapper.from(delegate.mapToInt(mapper)); + } + + public LongStream mapToLong(DoubleToLongFunction mapper) { + return wrapper.from(delegate.mapToLong(mapper)); + } + + public void close() { + delegate.close(); + } + + public DoubleStream flatMap(DoubleFunction mapper) { + return wrapper.from(delegate.flatMap(mapper)); + } + + public DoubleStream distinct() { + return wrapper.from(delegate.distinct()); + } + + public DoubleStream sorted() { + return wrapper.from(delegate.sorted()); + } + + public DoubleStream peek(DoubleConsumer action) { + return wrapper.from(delegate.peek(action)); + } + + public DoubleStream limit(long maxSize) { + return wrapper.from(delegate.limit(maxSize)); + } + + public DoubleStream skip(long n) { + return wrapper.from(delegate.skip(n)); + } + + public void forEach(DoubleConsumer action) { + delegate.forEach(action); + } + + public void forEachOrdered(DoubleConsumer action) { + delegate.forEachOrdered(action); + } + + public double[] toArray() { + return delegate.toArray(); + } + + public double reduce(double identity, DoubleBinaryOperator op) { + return delegate.reduce(identity, op); + } + + public OptionalDouble reduce(DoubleBinaryOperator op) { + return delegate.reduce(op); + } + + public R collect(Supplier supplier, ObjDoubleConsumer accumulator, BiConsumer combiner) { + return delegate.collect(supplier, accumulator, combiner); + } + + public double sum() { + return delegate.sum(); + } + + public OptionalDouble min() { + return delegate.min(); + } + + public OptionalDouble max() { + return delegate.max(); + } + + public long count() { + return delegate.count(); + } + + public OptionalDouble average() { + return delegate.average(); + } + + public DoubleSummaryStatistics summaryStatistics() { + return delegate.summaryStatistics(); + } + + public boolean anyMatch(DoublePredicate predicate) { + return delegate.anyMatch(predicate); + } + + public boolean allMatch(DoublePredicate predicate) { + return delegate.allMatch(predicate); + } + + public boolean noneMatch(DoublePredicate predicate) { + return delegate.noneMatch(predicate); + } + + public OptionalDouble findFirst() { + return delegate.findFirst(); + } + + public OptionalDouble findAny() { + return delegate.findAny(); + } + + public Stream boxed() { + return wrapper.from(delegate.boxed()); + } + + public DoubleStream sequential() { + return wrapper.from(delegate.sequential()); + } + + public DoubleStream parallel() { + return wrapper.from(delegate.parallel()); + } + + public OfDouble iterator() { + return delegate.iterator(); + } + + public java.util.Spliterator.OfDouble spliterator() { + return delegate.spliterator(); + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java new file mode 100644 index 000000000..f3ee72e16 --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingIntStream.java @@ -0,0 +1,188 @@ +package org.cryptomator.common.streams; + +import java.util.IntSummaryStatistics; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.PrimitiveIterator.OfInt; +import java.util.function.BiConsumer; +import java.util.function.IntBinaryOperator; +import java.util.function.IntConsumer; +import java.util.function.IntFunction; +import java.util.function.IntPredicate; +import java.util.function.IntToDoubleFunction; +import java.util.function.IntToLongFunction; +import java.util.function.IntUnaryOperator; +import java.util.function.ObjIntConsumer; +import java.util.function.Supplier; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +abstract class DelegatingIntStream implements IntStream { + + private final IntStream delegate; + private final DelegatingStreamFactory wrapper; + + public DelegatingIntStream(IntStream delegate, DelegatingStreamFactory wrapper) { + this.delegate = delegate; + this.wrapper = wrapper; + } + + public IntStream filter(IntPredicate predicate) { + return wrapper.from(delegate.filter(predicate)); + } + + public boolean isParallel() { + return delegate.isParallel(); + } + + public IntStream map(IntUnaryOperator mapper) { + return wrapper.from(delegate.map(mapper)); + } + + public Stream mapToObj(IntFunction mapper) { + return wrapper.from(delegate.mapToObj(mapper)); + } + + public IntStream unordered() { + return wrapper.from(delegate.unordered()); + } + + public LongStream mapToLong(IntToLongFunction mapper) { + return wrapper.from(delegate.mapToLong(mapper)); + } + + public IntStream onClose(Runnable closeHandler) { + return wrapper.from(delegate.onClose(closeHandler)); + } + + public DoubleStream mapToDouble(IntToDoubleFunction mapper) { + return wrapper.from(delegate.mapToDouble(mapper)); + } + + public void close() { + delegate.close(); + } + + public IntStream flatMap(IntFunction mapper) { + return wrapper.from(delegate.flatMap(mapper)); + } + + public IntStream distinct() { + return wrapper.from(delegate.distinct()); + } + + public IntStream sorted() { + return wrapper.from(delegate.sorted()); + } + + public IntStream peek(IntConsumer action) { + return wrapper.from(delegate.peek(action)); + } + + public IntStream limit(long maxSize) { + return wrapper.from(delegate.limit(maxSize)); + } + + public IntStream skip(long n) { + return wrapper.from(delegate.skip(n)); + } + + public void forEach(IntConsumer action) { + delegate.forEach(action); + } + + public void forEachOrdered(IntConsumer action) { + delegate.forEachOrdered(action); + } + + public int[] toArray() { + return delegate.toArray(); + } + + public int reduce(int identity, IntBinaryOperator op) { + return delegate.reduce(identity, op); + } + + public OptionalInt reduce(IntBinaryOperator op) { + return delegate.reduce(op); + } + + public R collect(Supplier supplier, ObjIntConsumer accumulator, BiConsumer combiner) { + return delegate.collect(supplier, accumulator, combiner); + } + + public int sum() { + return delegate.sum(); + } + + public OptionalInt min() { + return delegate.min(); + } + + public OptionalInt max() { + return delegate.max(); + } + + public long count() { + return delegate.count(); + } + + public OptionalDouble average() { + return delegate.average(); + } + + public IntSummaryStatistics summaryStatistics() { + return delegate.summaryStatistics(); + } + + public boolean anyMatch(IntPredicate predicate) { + return delegate.anyMatch(predicate); + } + + public boolean allMatch(IntPredicate predicate) { + return delegate.allMatch(predicate); + } + + public boolean noneMatch(IntPredicate predicate) { + return delegate.noneMatch(predicate); + } + + public OptionalInt findFirst() { + return delegate.findFirst(); + } + + public OptionalInt findAny() { + return delegate.findAny(); + } + + public LongStream asLongStream() { + return wrapper.from(delegate.asLongStream()); + } + + public DoubleStream asDoubleStream() { + return wrapper.from(delegate.asDoubleStream()); + } + + public Stream boxed() { + return wrapper.from(delegate.boxed()); + } + + public IntStream sequential() { + return wrapper.from(delegate.sequential()); + } + + public IntStream parallel() { + return wrapper.from(delegate.parallel()); + } + + public OfInt iterator() { + return delegate.iterator(); + } + + public java.util.Spliterator.OfInt spliterator() { + return delegate.spliterator(); + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java new file mode 100644 index 000000000..c33baef4f --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingLongStream.java @@ -0,0 +1,184 @@ +package org.cryptomator.common.streams; + +import java.util.LongSummaryStatistics; +import java.util.OptionalDouble; +import java.util.OptionalLong; +import java.util.PrimitiveIterator.OfLong; +import java.util.function.BiConsumer; +import java.util.function.LongBinaryOperator; +import java.util.function.LongConsumer; +import java.util.function.LongFunction; +import java.util.function.LongPredicate; +import java.util.function.LongToDoubleFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; +import java.util.function.ObjLongConsumer; +import java.util.function.Supplier; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +abstract class DelegatingLongStream implements LongStream { + + private final LongStream delegate; + private final DelegatingStreamFactory wrapper; + + public DelegatingLongStream(LongStream delegate, DelegatingStreamFactory wrapper) { + this.delegate = delegate; + this.wrapper = wrapper; + } + + public LongStream filter(LongPredicate predicate) { + return wrapper.from(delegate.filter(predicate)); + } + + public boolean isParallel() { + return delegate.isParallel(); + } + + public LongStream map(LongUnaryOperator mapper) { + return wrapper.from(delegate.map(mapper)); + } + + public Stream mapToObj(LongFunction mapper) { + return wrapper.from(delegate.mapToObj(mapper)); + } + + public LongStream unordered() { + return wrapper.from(delegate.unordered()); + } + + public LongStream onClose(Runnable closeHandler) { + return wrapper.from(delegate.onClose(closeHandler)); + } + + public IntStream mapToInt(LongToIntFunction mapper) { + return wrapper.from(delegate.mapToInt(mapper)); + } + + public DoubleStream mapToDouble(LongToDoubleFunction mapper) { + return wrapper.from(delegate.mapToDouble(mapper)); + } + + public void close() { + delegate.close(); + } + + public LongStream flatMap(LongFunction mapper) { + return wrapper.from(delegate.flatMap(mapper)); + } + + public LongStream distinct() { + return wrapper.from(delegate.distinct()); + } + + public LongStream sorted() { + return wrapper.from(delegate.sorted()); + } + + public LongStream peek(LongConsumer action) { + return wrapper.from(delegate.peek(action)); + } + + public LongStream limit(long maxSize) { + return wrapper.from(delegate.limit(maxSize)); + } + + public LongStream skip(long n) { + return wrapper.from(delegate.skip(n)); + } + + public void forEach(LongConsumer action) { + delegate.forEach(action); + } + + public void forEachOrdered(LongConsumer action) { + delegate.forEachOrdered(action); + } + + public long[] toArray() { + return delegate.toArray(); + } + + public long reduce(long identity, LongBinaryOperator op) { + return delegate.reduce(identity, op); + } + + public OptionalLong reduce(LongBinaryOperator op) { + return delegate.reduce(op); + } + + public R collect(Supplier supplier, ObjLongConsumer accumulator, BiConsumer combiner) { + return delegate.collect(supplier, accumulator, combiner); + } + + public long sum() { + return delegate.sum(); + } + + public OptionalLong min() { + return delegate.min(); + } + + public OptionalLong max() { + return delegate.max(); + } + + public long count() { + return delegate.count(); + } + + public OptionalDouble average() { + return delegate.average(); + } + + public LongSummaryStatistics summaryStatistics() { + return delegate.summaryStatistics(); + } + + public boolean anyMatch(LongPredicate predicate) { + return delegate.anyMatch(predicate); + } + + public boolean allMatch(LongPredicate predicate) { + return delegate.allMatch(predicate); + } + + public boolean noneMatch(LongPredicate predicate) { + return delegate.noneMatch(predicate); + } + + public OptionalLong findFirst() { + return delegate.findFirst(); + } + + public OptionalLong findAny() { + return delegate.findAny(); + } + + public DoubleStream asDoubleStream() { + return wrapper.from(delegate.asDoubleStream()); + } + + public Stream boxed() { + return wrapper.from(delegate.boxed()); + } + + public LongStream sequential() { + return wrapper.from(delegate.sequential()); + } + + public LongStream parallel() { + return wrapper.from(delegate.parallel()); + } + + public OfLong iterator() { + return delegate.iterator(); + } + + public java.util.Spliterator.OfLong spliterator() { + return delegate.spliterator(); + } + +} diff --git a/main/commons/src/main/java/org/cryptomator/common/DelegatingStream.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java similarity index 77% rename from main/commons/src/main/java/org/cryptomator/common/DelegatingStream.java rename to main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java index e0049f260..585bb8cd3 100644 --- a/main/commons/src/main/java/org/cryptomator/common/DelegatingStream.java +++ b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStream.java @@ -1,4 +1,4 @@ -package org.cryptomator.common; +package org.cryptomator.common.streams; import java.util.Comparator; import java.util.Iterator; @@ -24,21 +24,13 @@ import java.util.stream.Stream; abstract class DelegatingStream implements Stream { private final Stream delegate; - private final StreamWrapper wrapper; + private final DelegatingStreamFactory wrapper; - protected DelegatingStream(Stream delegate, StreamWrapper wrapper) { + protected DelegatingStream(Stream delegate, DelegatingStreamFactory wrapper) { this.delegate = delegate; this.wrapper = wrapper; } - private Stream wrapped(Stream other) { - if (getClass().isInstance(other)) { - return other; - } else { - return wrapper.wrap(other); - } - } - public Iterator iterator() { return delegate.iterator(); } @@ -52,19 +44,19 @@ abstract class DelegatingStream implements Stream { } public Stream sequential() { - return wrapped(delegate.sequential()); + return wrapper.from(delegate.sequential()); } public Stream parallel() { - return wrapped(delegate.parallel()); + return wrapper.from(delegate.parallel()); } public Stream unordered() { - return wrapped(delegate.unordered()); + return wrapper.from(delegate.unordered()); } public Stream onClose(Runnable closeHandler) { - return wrapped(delegate.onClose(closeHandler)); + return wrapper.from(delegate.onClose(closeHandler)); } public void close() { @@ -72,63 +64,63 @@ abstract class DelegatingStream implements Stream { } public Stream filter(Predicate predicate) { - return wrapped(delegate.filter(predicate)); + return wrapper.from(delegate.filter(predicate)); } public Stream map(Function mapper) { - return wrapped(delegate.map(mapper)); + return wrapper.from(delegate.map(mapper)); } public IntStream mapToInt(ToIntFunction mapper) { - return delegate.mapToInt(mapper); + return wrapper.from(delegate.mapToInt(mapper)); } public LongStream mapToLong(ToLongFunction mapper) { - return delegate.mapToLong(mapper); + return wrapper.from(delegate.mapToLong(mapper)); } public DoubleStream mapToDouble(ToDoubleFunction mapper) { - return delegate.mapToDouble(mapper); + return wrapper.from(delegate.mapToDouble(mapper)); } public Stream flatMap(Function> mapper) { - return wrapped(delegate.flatMap(mapper)); + return wrapper.from(delegate.flatMap(mapper)); } public IntStream flatMapToInt(Function mapper) { - return delegate.flatMapToInt(mapper); + return wrapper.from(delegate.flatMapToInt(mapper)); } public LongStream flatMapToLong(Function mapper) { - return delegate.flatMapToLong(mapper); + return wrapper.from(delegate.flatMapToLong(mapper)); } public DoubleStream flatMapToDouble(Function mapper) { - return delegate.flatMapToDouble(mapper); + return wrapper.from(delegate.flatMapToDouble(mapper)); } public Stream distinct() { - return wrapped(delegate.distinct()); + return wrapper.from(delegate.distinct()); } public Stream sorted() { - return wrapped(delegate.sorted()); + return wrapper.from(delegate.sorted()); } public Stream sorted(Comparator comparator) { - return wrapped(delegate.sorted(comparator)); + return wrapper.from(delegate.sorted(comparator)); } public Stream peek(Consumer action) { - return wrapped(delegate.peek(action)); + return wrapper.from(delegate.peek(action)); } public Stream limit(long maxSize) { - return wrapped(delegate.limit(maxSize)); + return wrapper.from(delegate.limit(maxSize)); } public Stream skip(long n) { - return wrapped(delegate.skip(n)); + return wrapper.from(delegate.skip(n)); } public void forEach(Consumer action) { @@ -199,10 +191,4 @@ abstract class DelegatingStream implements Stream { return delegate.findAny(); } - public interface StreamWrapper { - - Stream wrap(Stream other); - - } - } diff --git a/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java new file mode 100644 index 000000000..04b584180 --- /dev/null +++ b/main/commons/src/main/java/org/cryptomator/common/streams/DelegatingStreamFactory.java @@ -0,0 +1,51 @@ +package org.cryptomator.common.streams; + +import java.util.function.Function; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +public interface DelegatingStreamFactory { + + public static DelegatingStreamFactory of( // + ObjectStreamWrapper objectStreamWrapper, // + Function intStreamWrapper, // + Function longStreamWrapper, // + Function doubleStreamWrapper) { + return new DelegatingStreamFactory() { + @Override + public DoubleStream from(DoubleStream other) { + return doubleStreamWrapper.apply(other); + } + + @Override + public LongStream from(LongStream other) { + return longStreamWrapper.apply(other); + } + + @Override + public IntStream from(IntStream other) { + return intStreamWrapper.apply(other); + } + + @Override + public Stream from(Stream other) { + return objectStreamWrapper.from(other); + } + }; + } + + Stream from(Stream other); + + IntStream from(IntStream other); + + LongStream from(LongStream other); + + DoubleStream from(DoubleStream other); + + public interface ObjectStreamWrapper { + Stream from(Stream other); + } + +} \ No newline at end of file diff --git a/main/commons/src/test/java/org/cryptomator/common/AutoClosingStreamTest.java b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java similarity index 93% rename from main/commons/src/test/java/org/cryptomator/common/AutoClosingStreamTest.java rename to main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java index e831ecefa..475f2fcc1 100644 --- a/main/commons/src/test/java/org/cryptomator/common/AutoClosingStreamTest.java +++ b/main/commons/src/test/java/org/cryptomator/common/streams/AutoClosingStreamTest.java @@ -1,4 +1,4 @@ -package org.cryptomator.common; +package org.cryptomator.common.streams; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.is; @@ -11,6 +11,7 @@ import static org.mockito.Mockito.when; import java.util.function.Consumer; import java.util.stream.Stream; +import org.cryptomator.common.streams.AutoClosingStream; import org.junit.Before; import org.junit.Test; import org.mockito.InOrder; diff --git a/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/DefaultNioAccess.java b/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/DefaultNioAccess.java index 49707a35e..726e4a7f6 100644 --- a/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/DefaultNioAccess.java +++ b/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/DefaultNioAccess.java @@ -14,13 +14,8 @@ import java.nio.file.attribute.FileAttribute; import java.nio.file.attribute.FileTime; import java.util.stream.Stream; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - class DefaultNioAccess implements NioAccess { - private static final Logger LOG = LoggerFactory.getLogger(DefaultNioAccess.class); - @Override public FileChannel open(Path path, OpenOption... options) throws IOException { return FileChannel.open(path, options); diff --git a/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/NioFolder.java b/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/NioFolder.java index ccf842064..472ea3712 100644 --- a/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/NioFolder.java +++ b/main/filesystem-nio/src/main/java/org/cryptomator/filesystem/nio/NioFolder.java @@ -9,8 +9,8 @@ import java.time.Instant; import java.util.Optional; import java.util.stream.Stream; -import org.cryptomator.common.AutoClosingStream; import org.cryptomator.common.WeakValuedCache; +import org.cryptomator.common.streams.AutoClosingStream; import org.cryptomator.filesystem.File; import org.cryptomator.filesystem.Folder; import org.cryptomator.filesystem.Node; diff --git a/main/filesystem-nio/src/test/java/org/cryptomator/filesystem/nio/NioFolderTest.java b/main/filesystem-nio/src/test/java/org/cryptomator/filesystem/nio/NioFolderTest.java index 58baf7680..615813dc0 100644 --- a/main/filesystem-nio/src/test/java/org/cryptomator/filesystem/nio/NioFolderTest.java +++ b/main/filesystem-nio/src/test/java/org/cryptomator/filesystem/nio/NioFolderTest.java @@ -24,7 +24,7 @@ import java.util.Optional; import java.util.function.Supplier; import java.util.stream.Stream; -import org.cryptomator.common.AutoClosingStream; +import org.cryptomator.common.streams.AutoClosingStream; import org.cryptomator.filesystem.File; import org.cryptomator.filesystem.FileSystem; import org.cryptomator.filesystem.Folder;