import * as plugins from './taskbuffer.plugins'; import * as helpers from './taskbuffer.classes.helpers'; export interface ITaskFunction { (x?: any): PromiseLike; } export class Task { // man datory properties name: string; taskFunction: ITaskFunction; buffered: boolean; bufferMax: number; execDelay: number; // tasks to run before and after preTask: Task; afterTask: Task; // initialize by default running: boolean = false; bufferRunner = new helpers.BufferRunner(this); cycleCounter = new helpers.CycleCounter(this); idle: boolean = true; private _state: string = 'ready'; constructor(optionsArg: { /** * the task function to run, must return promise */ taskFunction: ITaskFunction; /** * any other task to run before */ preTask?: Task; /** * any other task to run after */ afterTask?: Task; /** * wether this task should run buffered */ buffered?: boolean; /** * the maximum buffer */ bufferMax?: number; /** * the execution delay, before the task is executed * only makes sense when running in buffered mode */ execDelay?: number; /** * the name of the task */ name?: string; }) { this.taskFunction = optionsArg.taskFunction; this.preTask = optionsArg.preTask; this.afterTask = optionsArg.afterTask; this.idle = !this.running; this.buffered = optionsArg.buffered; this.bufferMax = optionsArg.bufferMax; this.execDelay = optionsArg.execDelay; this.name = optionsArg.name; } /** * trigger the task. Will trigger buffered if this.buffered is true */ trigger(x?): Promise { if (this.buffered) { return this.triggerBuffered(x); } else { return this.triggerUnBuffered(x); } } /** * trigger task unbuffered. */ triggerUnBuffered(x?): Promise { return helpers.runTask(this, { x: x }); } /** * trigger task buffered. */ triggerBuffered(x?): Promise { return this.bufferRunner.trigger(x); } get state(): string { return this._state; } set state(stateArg: string) { if (stateArg === 'locked') { this._state = 'locked'; } else { plugins.smartlog.defaultLogger.log('error', 'state type ' + stateArg + ' could not be set'); } } }