conductor interface

Author: Wangdahai

src/common/Constant.ts

@@ -0,0 +1,4 @@
+export const enum Constant {
+    PROTOCOL_VERSION = 0,
+    PROTOCOL_MIN_VERSION = 0,
+}

src/common/ds/MessageQueue.ts

@@ -0,0 +1,27 @@
+import { Queue } from "./Queue";
+
+export class MessageQueue<T> {
+    private readonly __inputQueue: Queue<T> = new Queue();
+    private readonly __promiseQueue: Queue<Function> = new Queue();
+
+    push(item: T) {
+        if (this.__promiseQueue.length !== 0) this.__promiseQueue.pop()(item);
+        else this.__inputQueue.push(item);
+    }
+
+    async pop(): Promise<T> {
+        if (this.__inputQueue.length !== 0) return this.__inputQueue.pop();
+        return new Promise((resolve, _reject) => {
+            this.__promiseQueue.push(resolve);
+        });
+    }
+
+    tryPop(): T | undefined {
+        if (this.__inputQueue.length !== 0) return this.__inputQueue.pop();
+        return undefined;
+    }
+
+    constructor() {
+        this.push = this.push.bind(this);
+    }
+}

src/common/ds/Queue.ts

@@ -0,0 +1,51 @@
+/**
+ * A stack-based queue implementation.
+ * `push` and `pop` run in amortized constant time.
+ */
+export class Queue<T> {
+    /** The output stack. */
+    private __s1: T[] = [];
+    /** The input stack. */
+    private __s2: T[] = [];
+
+    /**
+     * Adds an item to the queue.
+     * @param item The item to be added to the queue.
+     */
+    push(item: T) {
+        this.__s2.push(item);
+    }
+
+    /**
+     * Removes an item from the queue.
+     * @returns The item removed from the queue.
+     * @throws If the queue is empty.
+     */
+    pop(): T {
+        if (this.__s1.length === 0) {
+            if (this.__s2.length === 0) throw new Error("queue is empty");
+            let temp = this.__s1;
+            this.__s1 = this.__s2.reverse();
+            this.__s2 = temp;
+        }
+        return this.__s1.pop()!; // as the length is nonzero
+    }
+
+    /**
+     * The length of the queue.
+     */
+    get length() {
+        return this.__s1.length + this.__s2.length;
+    }
+
+    /**
+     * Makes a copy of the queue.
+     * @returns A copy of the queue.
+     */
+    clone(): Queue<T> {
+        const newQueue = new Queue<T>();
+        newQueue.__s1 = [...this.__s1];
+        newQueue.__s2 = [...this.__s2];
+        return newQueue;
+    }
+}

src/common/ds/index.ts

@@ -0,0 +1,2 @@
+export { MessageQueue } from "./MessageQueue";
+export { Queue } from "./Queue";

src/common/errors/ConductorError.ts

@@ -0,0 +1,13 @@
+import { ErrorType } from "./ErrorType";
+
+/**
+ * Generic Conductor Error.
+ */
+export class ConductorError extends Error {
+    override name = "ConductorError";
+    readonly errorType: ErrorType | string = ErrorType.UNKNOWN;
+    
+    constructor(message: string) {
+        super(message);
+    }
+}

src/common/errors/ConductorInternalError.ts

@@ -0,0 +1,14 @@
+import { ConductorError } from "./ConductorError";
+import { ErrorType } from "./ErrorType";
+
+/**
+ * Conductor internal error, probably caused by developer oversight.
+ */
+export class ConductorInternalError extends ConductorError {
+    override name = "ConductorInternalError";
+    override readonly errorType: ErrorType | string = ErrorType.INTERNAL;
+    
+    constructor(message: string) {
+        super(message);
+    }
+}

src/common/errors/ErrorType.ts

@@ -0,0 +1,8 @@
+export const enum ErrorType {
+    UNKNOWN = "__unknown",
+    INTERNAL = "__internal",
+    EVALUATOR = "__evaluator",
+    EVALUATOR_SYNTAX = "__evaluator_syntax",
+    EVALUATOR_TYPE = "__evaluator_type",
+    EVALUATOR_RUNTIME = "__evaluator_runtime",
+}

src/common/errors/EvaluatorError.ts

@@ -0,0 +1,26 @@
+import { ConductorError } from "./ConductorError";
+import { ErrorType } from "./ErrorType";
+
+/**
+ * Generic evaluation error, caused by a problem in user code.
+ */
+export class EvaluatorError extends ConductorError {
+    override name = "EvaluatorError";
+    override readonly errorType: ErrorType | string = ErrorType.EVALUATOR;
+
+    readonly rawMessage: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly fileName?: string
+
+    constructor(message: string, line?: number, column?: number, fileName?: string) {
+        const location = line !== undefined
+            ? `${fileName ? fileName + ":" : ""}${line}${column !== undefined ? ":" + column : ""}: `
+            : "";
+        super(`${location}${message}`);
+        this.rawMessage = message;
+        this.line = line;
+        this.column = column;
+        this.fileName = fileName
+    }
+}

src/common/errors/EvaluatorRuntimeError.ts

@@ -0,0 +1,10 @@
+import { ErrorType } from "./ErrorType";
+import { EvaluatorError } from "./EvaluatorError";
+
+/**
+ * Evaluator runtime error - some problem occurred while running the user code.
+ */
+export class EvaluatorRuntimeError extends EvaluatorError {
+    override name = "EvaluatorRuntimeError";
+    override readonly errorType: ErrorType | string = ErrorType.EVALUATOR_RUNTIME;
+}

src/common/errors/EvaluatorSyntaxError.ts

@@ -0,0 +1,10 @@
+import { ErrorType } from "./ErrorType";
+import { EvaluatorError } from "./EvaluatorError";
+
+/**
+ * Evaluator syntax error - the user code does not follow the evaluator's prescribed syntax.
+ */
+export class EvaluatorSyntaxError extends EvaluatorError {
+    override name = "EvaluatorSyntaxError";
+    override readonly errorType: ErrorType | string = ErrorType.EVALUATOR_SYNTAX;
+}