simscript/dist/simulation.d.ts

A Discrete Event Simulation Library in TypeScript

import { Entity } from './entity';
import { RandomVar } from './random';
import { Queue } from './queue';
import { Event, EventArgs } from './event';
export declare enum SimulationState {
    Paused = 0,
    Finished = 1,
    Running = 2
}
export declare class Simulation {
    _fec: FecItem[];
    private _name;
    private _timeUnit;
    private _tmNow;
    private _tmEnd;
    private _tmMaxStep;
    private _frameDelay;
    private _tmStart;
    private _tmElapsed;
    private _state;
    private _queues;
    private _lastYield;
    private _lastFrame;
    private _yieldInterval;
    constructor(options?: any);
    get name(): string;
    set name(value: string);
    get timeUnit(): string;
    set timeUnit(value: string);
    get state(): SimulationState;
    get timeEnd(): number | null;
    set timeEnd(value: number | null);
    get maxTimeStep(): number | null;
    set maxTimeStep(value: number | null);
    get frameDelay(): number | null;
    set frameDelay(value: number | null);
    get timeElapsed(): number;
    get timeNow(): number;
    get yieldInterval(): number;
    set yieldInterval(value: number);
    start(reset?: boolean): Promise<void>;
    stop(reset?: boolean): void;
    activate(e: Entity): Promise<number>;
    generateEntities(entityType: any, interArrival?: RandomVar | number, max?: number, startTime?: number, endTime?: number): void;
    get queues(): Queue[];
    getStatsTable(showNetValues?: boolean): string;
    readonly starting: Event<Simulation, EventArgs>;
    onStarting(e?: EventArgs): void;
    readonly started: Event<Simulation, EventArgs>;
    onStarted(e?: EventArgs): void;
    readonly finishing: Event<Simulation, EventArgs>;
    onFinishing(e?: EventArgs): void;
    readonly finished: Event<Simulation, EventArgs>;
    onFinished(e?: EventArgs): void;
    readonly stateChanging: Event<Simulation, EventArgs>;
    onStateChanging(e?: EventArgs): void;
    readonly stateChanged: Event<Simulation, EventArgs>;
    onStateChanged(e?: EventArgs): void;
    readonly timeNowChanging: Event<Simulation, EventArgs>;
    onTimeNowChanging(e?: EventArgs): void;
    readonly timeNowChanged: Event<Simulation, EventArgs>;
    onTimeNowChanged(e?: EventArgs): void;
    protected _setState(value: SimulationState): void;
    protected _setTimeNow(value: number): void;
    protected _reset(): void;
    private _step;
    private _scanFec;
    private _createSimulationReport;
    private _createQueueReport;
}
export interface IFecItemOptions {
    delay?: number;
    path?: IMovePath;
    queue?: Queue;
    units?: number;
    signal?: any;
    ready?: boolean;
}
export declare class FecItem {
    private _e;
    private _ready;
    private _tmStart;
    private _tmDue;
    private _promise;
    private _resolve;
    private _options;
    constructor(e: Entity, options: IFecItemOptions);
    get e(): Entity;
    get options(): IFecItemOptions;
    get ready(): boolean;
    set ready(value: boolean);
    get timeStart(): number;
    get timeDue(): number;
    dispatch(): Promise<any>;
    get promise(): Promise<number>;
}
export interface IMovePath {
    queues: Queue[];
    tension?: number;
    radius?: number;
}