Class CellExecutionQueue

src/kernels/execution/cellExecutionQueue.ts:25–334

 * All cells queued using `queueCell` are added to the queue and processed in order they were added/queued.
 */
export class CellExecutionQueue implements Disposable {
    private readonly queueOfItemsToExecute: (ICellExecution | ICodeExecution)[] = [];
    private get queueOfCellsToExecute(): ICellExecution[] {
        return this.queueOfItemsToExecute.filter((c) => c.type === 'cell').map((c) => c as ICellExecution);
    }
    private cancelledOrCompletedWithErrors = false;
    private startedRunningCells = false;
    private disposables: Disposable[] = [];
    private lastCellExecution?: ICellExecution | ICodeExecution;
    /**
     * Whether all cells have completed processing or cancelled, or some completed & others cancelled.
     */
    public get isEmpty(): boolean {
        return this.queueOfItemsToExecute.length === 0;
    }
    /**
     * Whether cells have been cancelled (as a result of interrupt or some have failed).
     * Even if this property is true, its possible there is still some async operation pending (updating states of cells).
     */
    public get failed(): boolean {
        return this.cancelledOrCompletedWithErrors;
    }
    public get queue(): Readonly<NotebookCell[]> {
        return this.queueOfCellsToExecute.map((cell) => cell.cell);
    }
    constructor(
        private readonly session: Promise<IKernelSession>,
        private readonly executionFactory: CellExecutionFactory,
        readonly metadata: Readonly<KernelConnectionMetadata>,
        readonly resourceUri: Resource,
        private readonly notebook?: NotebookDocument,
        private readonly snapshotService?: ISnapshotMetadataService
    ) {}

    public dispose() {
        this.disposables.forEach((d) => d.dispose());
        this.lastCellExecution?.dispose();
    }

    /**
     * Queue the cell for execution & start processing it immediately.
     */
    public queueCell(cell: NotebookCell, codeOverride?: string): void {
        this.enqueue({ cell, codeOverride });
    }
    /**
     * Queue the code for execution & start processing it immediately.
     */
    public queueCode(code: string, extensionId: string, token: CancellationToken): ICodeExecution {
        const item = this.enqueue({ code, extensionId, token });
        return item as ICodeExecution;
    }
    private enqueue(
        options:
            | {
                  cell: NotebookCell;
                  events?: {
                      started: EventEmitter<void>;