import {collector, IConsumer, List, predicate} from "./Interface"; import {biConsumer,supplier,Func} from "./Interface"; import {ArrayList} from "./utils/ArrayList"; import {StreamImpl, Streams} from "./stream/Streams"; import {Objects} from "./type/Objects"; /***/ //MOCK interface stringBuilder extends IConsumer{ } /***/ //MOCK class StringBuilder implements stringBuilder{ private value:string[] = []; private readonly delimiter:string; constructor(delimiter:string = "") { this.delimiter = delimiter; } accept(o: string): void { this.value.push(o); } toString():string{return this.value.join(this.delimiter);} } class CollectorsImpl implements collector{ /**** * */ private readonly consumerFn:biConsumer; private readonly supplierFn:supplier; private readonly finisherFn:Func /*** * * @param supplier * @param consumer * @param finisher */ public constructor(supplier?:supplier,consumer?:biConsumer, finisher?:Func) { this.consumerFn = consumer; this.supplierFn = supplier; this.finisherFn = finisher; } /**** * */ public supplier(): supplier {return Objects.requireNotNull(this.supplierFn);} /**** * */ public accumulator(): biConsumer {return Objects.requireNotNull(this.consumerFn);} /**** * */ public finisher(): Func {return Objects.requireNotNull(this.finisherFn);} } export abstract class Collectors{ /*** * @CollectorsImpl */ public static CollectorImpl = CollectorsImpl; /*** * @toArray : * @returns Collector * @types T */ public static toArray( ):collector { /*** * */ return new class extends CollectorsImplimplements collector { /*** * */ supplier = (): supplier => new class implements supplier{ get = ():T[] => [] } /*** * */ accumulator = (): biConsumer => new class implements biConsumer{ accept = (ta: T[], v: T) => ta[ta.length] = v; } finisher = (): Func => (o:T[])=> o; } } /*** * @toList */ public static toList():collector, List> { /*** * */ return new class extends CollectorsImpl, List> implements collector, List>{ /*** * */ supplier = (): supplier> => new class implements supplier>{ get = ( ): List => new ArrayList(); }; /*** * */ accumulator = (): biConsumer, T> => new class implements biConsumer, T>{ accept = (ta:List, v:T) => ta.add(v); }; /*** * */ finisher = (): Func, List> => (a:List)=> a; } } public static filtering( predicate:predicate, collector: collector):collector { let consumer:biConsumer = collector.accumulator(); return new class extends CollectorsImpl implements collector{ /*** * */ supplier= collector.supplier; finisher = collector.finisher; /*** * */ accumulator = (): biConsumer => new class implements biConsumer{ accept = (ta:A, v:T)=> predicate.test(v) ? consumer.accept(ta,v) : void 0; } } } public static map( func:Func, collector: collector):collector { let consumer:biConsumer = collector.accumulator(); return new class extends CollectorsImpl implements collector{ /*** * */ supplier = collector.supplier; finisher = collector.finisher; /*** * */ accumulator = (): biConsumer => new class implements biConsumer{ accept = (ta:A, v:T)=> consumer.accept(ta, func(v)); } } } public static join(delimiter:string= " "):collector { return new class extends CollectorsImpl implements collector{ /*** * */ supplier = (): supplier => new class implements supplier{ get = ( ): StringBuilder => new StringBuilder(delimiter); } /*** * */ accumulator = (): biConsumer => new class implements biConsumer{ accept = (ta:StringBuilder, v:T)=> ta.accept(v); } finisher = (): Func => (a:StringBuilder)=> a.toString() } } /*** * */ public static toArrays( ):collector, StreamImpl> { return new class extends CollectorsImpl, StreamImpl> implements collector, StreamImpl> { supplier(): supplier> { return new class implements supplier>{ get = ():StreamImpl => new Streams.StreamBuilder(); }; } accumulator(): biConsumer, T> { return new class implements biConsumer, T>{ accept = (ta: StreamImpl, v: T) => ta.accept(v); }; } } } } Object.package(this);