import { Func, intPredicate, intStream, IntStreamBuilder, predicate, predicateFn, spliterator, supplier, collector, ObjIntConsumer, supplierFn, Stream } from "../Interface"; import {Streams} from "./Streams"; import { Spliterator } from "../utils/Spliterator"; import {OptionalInt} from "../utils/OptionalInt"; import {ForEachOps} from "./ForEachOps"; import {BiConsumer, IntConsumer} from "../Consumer"; import {UnsupportedOperationException} from "../Exception"; import {AbstractPipeline} from "./AbstractPipeline"; import {Sink, sink} from "./Sink"; import {StreamShape} from "./StreamShape"; import {Predication} from "../utils/Predication"; import {ReduceOps} from "./ReduceOps"; import {FindOps} from "./FindOps"; import {ArrayA} from "../type/ArrayA"; import {MatchOps} from "./MatchOps"; import {ReferencePipelineImpl} from "./ReferencePipeline"; import {flombok} from "../flombok"; import {SliceOps} from "./SliceOps"; import {Integer} from "../type/Integer"; import {Objects} from "../type/Objects"; export abstract class IntPipeline extends AbstractPipeline implements intStream { /*** */ protected constructor(value:Spliterator|AbstractPipeline|supplier>, sourceFlag:number) { super(value,sourceFlag); } public getOutputShape(): StreamShape{return StreamShape.INT_VALUE;} public allMatch(predicate: intPredicate) :boolean { return this.evaluate(MatchOps.makeInt(Predication.of(predicate), MatchOps.MatchKind.ALL)); } public anyMatch(predicate: intPredicate):boolean { return this.evaluate(MatchOps.makeInt(Predication.of(predicate), MatchOps.MatchKind.ANY )); } public noneMatch(predicate: intPredicate): boolean { return this.evaluate(MatchOps.makeInt(Predication.of(predicate), MatchOps.MatchKind.NONE )); } /*** * */ public average(): OptionalInt { let av = new class Average implements supplier>, ObjIntConsumer>{ get: supplierFn> = ()=> [0,0]; accept(t: Array, value: number): void { t[0]++; t[1] += value; } }; let tmp: Array = this.collect(av, av); return tmp[0] > 0 ? OptionalInt.of(tmp[1] / tmp[0] ) : OptionalInt.empty(); } /*** * @param {supplier} supplier * @param {ObjIntConsumer} consumer * @param {BiConsumer} combiner * @returns {R} */ public collect(supplier: supplier, consumer:ObjIntConsumer, combiner?:BiConsumer): R { return this.evaluate(ReduceOps.makeIntSupplier(supplier,consumer)); } /**** * * @param {collector} collector * @returns {R} */ public collector(collector:collector):R{ return this.collect( collector.supplier(), new class implements ObjIntConsumer{ accept(t: R, value: number) { collector.accumulator().accept(t,value); } }, null); } /*** * * @param {IntConsumer} consumer */ public each(consumer: IntConsumer ): void { this.evaluate(ForEachOps.makeInt(consumer)); } /**** * * @param {sink} sink * @param {spliterator} spliterator * @returns {boolean} */ public forEachWithCancel(sink: sink,spliterator: spliterator): boolean { let canceled:boolean; do{}while( !( canceled = sink.cancellationRequested() ) && spliterator.tryAdvance(sink) ); return canceled; } /** * */ public limit(value: number): intStream { return SliceOps.makeInt(this,0,value); } /*** * * @param {predicateFn} predicate * @returns {intStream} */ public filter(predicate: predicateFn): intStream { let p:predicate = Predication.of(Objects.requireNotNull(predicate)), slf:this = this; return new class extends StatelessOp{ constructor() {super(slf,slf.getStreamAndOpFlags());} opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedInt{ constructor() {super(sink);} /**@override**/ accept(value:number){ if(p.test(value)) this.downstream.accept(value); } } } }; } /** * @return {number} */ public count(): number {return this.map(()=>1).sum();} /** * **/ public sum(): number {return this.reduceIdentity(0,Number.sum);} /*** * * @returns {OptionalInt} */ public findAny(): OptionalInt { return this.evaluate(FindOps.makeInt(false)) } /*** * * @returns {OptionalInt} */ public findFirst(): OptionalInt { return this.evaluate(FindOps.makeInt(true)) } /*** * @param {Func} supplier * @returns {intStream} */ public map(supplier: Func): intStream { let slf:this = this; return new class extends StatelessOp{ constructor() {super(slf, slf.getStreamAndOpFlags());} opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedInt{ constructor() {super(sink);} /**@override**/ accept(o: number) { this.downstream.accept(supplier.call(null,o)) } }; } }; } /*** * * @param supplier */ public mapToObj(supplier: Func):Stream { let slf:this = this; Objects.requireNotNull(supplier); return new class extends ReferencePipelineImpl.StateOps{ constructor() {super(slf,0);} opWrapSink(flags: number, sink: sink): sink { return new class extends Sink.ChainedInt{ constructor() {super(sink);} /**@override**/ accept(o: number) { this.downstream.accept(supplier.call(null,o)) } }; } }; } /** * */ public boxed( ):Stream{ return this.mapToObj(Integer.of); } /*** * @returns {OptionalInt} */ public max(): OptionalInt {return this.reduce(Math.max);} /*** * @returns {OptionalInt} */ public min(): OptionalInt {return this.reduce(Math.min);} /*** * @returns {OptionalInt} */ @flombok.FINAL() public reduce(op:Function): OptionalInt {return this.evaluate(ReduceOps.makeIntOperator(op));} /*** * @param identity * @param op */ @flombok.FINAL() public reduceIdentity(identity:number, op:Function):number{ return this.evaluate(ReduceOps.makeIntOperatorN(identity, op)); } /**** * @returns {IntStreamBuilder} */ public static builder():IntStreamBuilder{return new Streams.IntStreamBuilder();} /** * */ public static of(... value:T[]){return ArrayA.list(value).stream()} } class Head extends IntPipeline implements intStream { constructor(split:Spliterator|supplier>, sourceFlag:number) { super(split,sourceFlag); } opIsStateful(): boolean { throw new UnsupportedOperationException(); } opWrapSink(flags: number, sink: sink): sink {throw new UnsupportedOperationException();} each(consumer: IntConsumer) {super.each(consumer);} } class StatelessOp extends IntPipeline implements intStream { constructor(streamParent: AbstractPipeline, sourceFlag:number) { super(streamParent,sourceFlag); } opIsStateful(): boolean {return false;} opWrapSink(flags: number, sink: sink): sink {return null;} each(consumer: IntConsumer) {super.each(consumer);} } class StateFulOp extends IntPipeline implements intStream { constructor(streamParent: AbstractPipeline, opFlags:number) { super(streamParent,opFlags); } opIsStateful(): boolean {return true;} opWrapSink(flags: number, sink: sink): sink {return null;} } export abstract class IntPipelineImpl { /**** * */ public static Head = Head; /**** * */ public static StaleFull = StateFulOp; /*** * */ public static StalelessOp = StatelessOp }