import {Node, PipelineHelper} from "./PipelineHelper"; import {spliterator, supplier} from "../Interface"; import {Spliterator} from "../utils/Spliterator"; import {StreamShape} from "./StreamShape"; import {sink} from "./Sink"; import {terminalOps} from "./TerminalOps"; import {Supplier} from "../utils/Supplier"; import {RuntimeException} from "../Exception"; import assert = require("assert"); // @ts-ignore export abstract class AbstractPipeline extends PipelineHelper{ private readonly sourceStage:AbstractPipeline; protected previousStage:AbstractPipeline; private nextStage:AbstractPipeline; private sourceSplit:spliterator; private sourceSupplier: supplier; private linkedOrConsumed:boolean = false; protected depth:number = 0; private combinedFlag:number = 0; protected constructor(value:Spliterator|Supplier>|AbstractPipeline, opFlags:number) { super(); if( value instanceof Spliterator ){ this.sourceSplit = value; this.sourceStage = this; this.previousStage = this.nextStage = null; }else if(value instanceof Supplier ){ this.sourceSplit = null; this.sourceStage = this; this.sourceSupplier = value; this.previousStage = this.nextStage = null; // upstream }else if(value instanceof AbstractPipeline ){ value.linkedOrConsumed = true; // @ts-ignore value.nextStage = this; // @ts-ignore this.previousStage = value; // @ts-ignore this.sourceStage = value.sourceStage; this.nextStage = null; this.depth = value.depth + 1; this.combinedFlag = opFlags; } } // Parallel ?? public abstract opIsStateful():boolean; /** * @opWrapSink: to Implement with : * + Head => throw * + StateLessOp * + StateFulOp * */ public abstract opWrapSink(flags:number, sink:sink):sink; /**** * @evaluate * @returns {R} */ public evaluate(terminalOps: terminalOps):R{ assert.strictEqual( this.getOutputShape().equals(terminalOps.inputShape()), true); if(this.linkedOrConsumed) throw new RuntimeException("stream has already been operated upon or closed"); this.linkedOrConsumed=true; return terminalOps.evaluateSequential(this,this.sourceSpliterator(terminalOps.getOpFlag())); } /** * PipelineHelper Handler * */ public getSourceShape():StreamShape{ return null; }; /*** * @getOutputShape * @toImplement */ public abstract getOutputShape():StreamShape; /*** * @getOutputShape * @toOverride */ public getStreamAndOpFlags(): number {return this.combinedFlag;} public wrapAndCopyInto>(sink: S, spliterator: Spliterator ):S { this.copyInto(this.wrapSink(sink),spliterator); return sink; } public copyInto(wrappedSink: sink, spliterator: Spliterator):void{ if( this.getStreamAndOpFlags() == 1 ) this.copyIntoWithCancel(wrappedSink,spliterator); else { wrappedSink.begin(spliterator.estimateSize()); spliterator.forEachRemaining(wrappedSink); wrappedSink.end(); } } public copyIntoWithCancel(wrappedSink: sink, spliterator: Spliterator) { let tmp: AbstractPipeline = this, canceled:boolean; while (tmp.depth > 0) tmp = tmp.previousStage; wrappedSink.begin(spliterator.estimateSize()); // @ts-ignore canceled = tmp.forEachWithCancel(wrappedSink,spliterator); wrappedSink.end(); return canceled; } public wrapSink(sk:sink): sink { for(let ptr: AbstractPipeline = this; ptr.depth > 0; ptr = ptr.previousStage ){ //console.log("======== =====================================") // console.log(ptr.depth ) // console.log("=======================================================================================================================================") sk = ptr.opWrapSink(0, sk); // console.log(sk) } // @ts-ignore return (>sk); } public evaluateHelper(spliterator: Spliterator, flatten: boolean): Node { return undefined; } private sourceSpliterator(terminalFlags:number): spliterator{ let tmp: spliterator = null; if(this.sourceStage.sourceSplit != null ){ tmp = this.sourceStage.sourceSplit; this.sourceStage.sourceSplit = null; }else if(this.sourceStage.sourceSupplier != null ){ tmp = this.sourceStage.sourceSupplier.get(); this.sourceStage.sourceSupplier=null; }else{ throw new RuntimeException("source already consumed or closed"); } // parallel Ctrl ... if( terminalFlags!=0) this.combinedFlag = terminalFlags; return tmp; } public abstract forEachWithCancel( sink:sink, spliterator:spliterator):boolean; } Object.package(this);