import {AbstractPipeline} from "./AbstractPipeline"; import {StreamShape} from "./StreamShape"; import {Sink, sink} from "./Sink" import {IllegalArgumentException, UnsupportedOperationException} from "../Exception"; import {Spliterator} from "../utils/Spliterator"; import { collector, comparator, Func, optional, predicate, predication, spliterator, Stream, supplier, consumer, biConsumer, intStream, ToTypeFunction } from "../Interface"; import {Supplier} from "../utils/Supplier"; import {ForEachOps} from "./ForEachOps"; import {Consumer} from "../Consumer"; import {FindOps} from "./FindOps"; import {Predication} from "../utils/Predication"; import {MatchOps} from "./MatchOps"; import {Objects} from "../type/Objects"; import {ReduceOps} from "./ReduceOps"; import {Collectors} from "../Collectors"; import {IntPipelineImpl} from "./IntPipeline"; import {SliceOps} from "./SliceOps"; import {Optional} from "../utils/Optional"; import {BinaryOperator} from "../utils/BinaryOperator"; export abstract class ReferencePipeline extends AbstractPipeline> implements Stream{ protected constructor(value:Spliterator|Supplier>|AbstractPipeline, sourceFlag:number) { super(value,sourceFlag); } public getOutputShape(): StreamShape {return StreamShape.REFERENCE;} public abstract opWrapSink(flags: number, sink: sink): sink; /*** * Most easy case * @param {consumer} consumer */ public each(consumer:consumer): void { this.evaluate(new ForEachOps.OfRef(Consumer.of(consumer))) } /*** * * @param {Func} mapper * @return {Stream} */ public map(mapper: Func): Stream { let slf:this = this; Objects.requireNotNull(mapper); return new class extends StateOps{ constructor() {super(slf,0);} /**@override**/ opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedReference{ constructor() {super(sink);} /**@override**/ accept(o: P_OUT) { this.downstream.accept(mapper.call(o,o)); } }; } }; } /*** * * @param {ToTypeFunction} mapper * @return {intStream} */ public mapToInt(mapper:ToTypeFunction):intStream{ Objects.requireNotNull(mapper); let slf:this = this; return new class extends IntPipelineImpl.StalelessOp{ // @ts-ignore constructor() {super(slf, StreamShape.REFERENCE);} public opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedReference{ constructor() {super(sink);} /***@override*/ public accept(o: P_OUT) { this.downstream.accept(mapper.applyAs(o)); } }; } }; } sort(comparator: comparator): Stream { return undefined; } /*** * * @return {optional} */ public findAny(): optional { return this.evaluate(FindOps.makeRef(false)); } /*** * * @param {predication} predicate * @return {boolean} */ public allMatch(predicate: predication): boolean { return this.evaluate(MatchOps.makeRef(predicate,MatchOps.MatchKind.ALL)); } /*** * */ public anyMatch(predicate: predication): boolean { return this.evaluate(MatchOps.makeRef(Predication.of(predicate),MatchOps.MatchKind.ANY)); } /*** * * @return {number} */ public count(): number { class Dummy implements ToTypeFunction{ public applyAs(type: P_OUT): number {return 1;} } return this.mapToInt(new Dummy()).sum(); } /*** * * @param {predication} predicate * @return {Stream} */ public filter(predicate: predication): Stream { let slf:this = this, p:predicate; Objects.requireNotNull(predicate); p = Predication.of(predicate); return new class extends StateOps{ constructor() {super(slf,slf.getStreamAndOpFlags());} opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedReference{ constructor() {super(sink);} /**@override**/ accept(o: P_OUT) { if( p.test(o) ) this.downstream.accept(o); } }; } }; } public flatMap>(mapper: Func): Stream { let slf:this = this; Objects.requireNotNull(mapper()); return new class extends StateOps{ constructor() {super(slf,slf.getStreamAndOpFlags());} public opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedReference{ constructor() {super(sink);} /**@override**/ accept(o: P_OUT) { try{ let tmp:Stream = mapper(o); if(tmp!=null)tmp.each(this.downstream); }catch (e) {} } }; } }; } /*** * * @return {optional} */ public findFirst(): optional { return this.evaluate(FindOps.makeRef(true)); } /*** * * @param {number} maxValue * @return {Stream} */ public limit(maxValue: number): Stream { if(maxValue<0) throw new IllegalArgumentException(); return SliceOps.makeRef(this, 0, maxValue); } /*** * * @param {predication} predicate * @return {boolean} */ public noneMatch(predicate: predication): boolean { return this.evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.NONE)); } /*public reduceA(identit:P_OUT, accumulator:Function ):P_OUT{ }*/ /*** * * @param {Function} accumulator * @return {Optional} */ public reduce(accumulator:BinaryOperator):Optional{ return this.evaluate(ReduceOps.makeRefOperator(BinaryOperator.from(accumulator))); } /*** * @param {comparator} comparator * @return {Optional} */ public min(comparator:comparator):Optional{ return this.reduce(BinaryOperator.minBy(comparator)); } /*** * @param {comparator} comparator * @return {Optional} */ public max(comparator:comparator):Optional{ return this.reduce(BinaryOperator.maxBy(comparator)); } /*** * * @param {supplier} supplier * @param {biConsumer} biConsumer * @return {R} */ public collect(supplier:supplier, biConsumer: biConsumer):R{ return this.evaluate(ReduceOps.makeRef(supplier,biConsumer)); } /*** * * @param {collector} collector * @return {R} */ public collector(collector: collector): R { return collector.finisher().call(null,this.evaluate(ReduceOps.makeRefCollect(collector))); } /*** * * @param {sink} sink * @param {spliterator} spliterator * @return {boolean} */ public forEachWithCancel(sink: sink,spliterator: spliterator): boolean { let canceled:boolean; do{}while( !( canceled = sink.cancellationRequested() ) && spliterator.tryAdvance(sink) ); return canceled; } /**/ public toObjectArray():Object[]{return this.collector(Collectors.toArray());} /*** * * @return {Object[]} */ public toArray(): P_OUT[] {return this.toObjectArray();} } class Head extends ReferencePipeline{ constructor(value:Spliterator|supplier>, opFlags:number) { super(value,opFlags); } opWrapSink(flags: number, sink: sink): sink {throw new UnsupportedOperationException();} opIsStateful(): boolean { throw new UnsupportedOperationException();} each(consumer:Consumer):void {super.each(consumer);} } class StateOps extends ReferencePipeline{ constructor(value:AbstractPipeline, opFlags:number) { super(value, opFlags); } opWrapSink(flags: number, sink: sink): sink {throw new UnsupportedOperationException();} opIsStateful(): boolean { throw new UnsupportedOperationException();} each(consumer:Consumer):void {super.each(consumer);} } class StateOpFulOp extends ReferencePipeline{ constructor(value:AbstractPipeline, opFlags:number) {super(value, opFlags);} opIsStateful(): boolean { return true; } opWrapSink(flags: number, sink: sink): sink {return null;} } export abstract class ReferencePipelineImpl{ /*** * * @type {Head} */ public static readonly Head = Head; /*** * * @type {StateOps} */ public static readonly StateOps = StateOps; /*** * * @type {StateOpFulOp} */ public static readonly StateFulOp = StateOpFulOp; } Object.package(this);