@woosh/meep-engine/src/core/process/executor/ConcurrentExecutor.d.ts

Pure JavaScript game engine. Fully featured and production ready.

export default ConcurrentExecutor;
/**
 * @class
 */
declare class ConcurrentExecutor {
    /**
     *
     * @param {number} [quietTime] in milliseconds
     * @param {number} [workTime] in milliseconds
     * @constructor
     */
    constructor(quietTime?: number, workTime?: number);
    /**
     *
     * @type {number}
     */
    quietTime: number;
    /**
     *
     * @type {number}
     */
    workTime: number;
    /**
     * Tasks in state pending resolution or initial sate are put here
     * @type {Task[]}
     */
    queueUnresolved: Task[];
    /**
     * ready tasks are those who's dependencies have all been completed
     * @type {Task[]}
     */
    queueReady: Task[];
    on: {
        task_started: Signal<any, any, any, any, any, any, any, any>;
        task_completed: Signal<any, any, any, any, any, any, any, any>;
        completed: Signal<any, any, any, any, any, any, any, any>;
    };
    busy: boolean;
    /**
     *
     * @type {number|SchedulingPolicy}
     */
    policy: number | SchedulingPolicy;
    /**
     *
     * @param {TaskGroup} taskGroup
     */
    runGroup(taskGroup: TaskGroup): void;
    /**
     *
     * @param {TaskGroup} group
     */
    removeGroup(group: TaskGroup): void;
    /**
     *
     * @param {Task} task
     * @return {boolean}
     */
    removeTask(task: Task): boolean;
    /**
     *
     * @param {Task} task
     */
    run(task: Task): void;
    /**
     * Shortcut for {@link #run} method for scheduling multiple tasks at once
     * @param {Task[]} tasks
     */
    runMany(tasks: Task[]): void;
    /**
     * @private
     * @param {Task} task
     * @returns {boolean}
     */
    private startTask;
    /**
     * Go through unresolved queue and move tasks whose dependencies have been completed to ready queue or fail them
     */
    resolveTasks(): void;
    /**
     *
     * @param {Task} task
     * @returns {boolean}
     */
    contains(task: Task): boolean;
    /**
     * kicks the scheduler into action, this is an internal method and should not be called from outside
     * @private
     */
    private prod;
    join(callback: any): void;
    #private;
}
declare namespace ConcurrentExecutor {
    export { SchedulingPolicy as POLICY };
}
import Signal from "../../events/signal/Signal.js";
type SchedulingPolicy = number;
declare namespace SchedulingPolicy {
    let ROUND_ROBIN: number;
    let SEQUENTIAL: number;
    let TIME_SLICE: number;
}
//# sourceMappingURL=ConcurrentExecutor.d.ts.map