@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/parser/operation/OperationParser.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationParser = void 0;
+const OperationState_1 = require("./OperationState");
+const XID3_1 = require("../../../xid/XID3");
+const Tokenizer_1 = require("../token/Tokenizer");
+const Token_1 = require("../token/Token");
+const SleepOperation_1 = require("../../../operation/SleepOperation");
+const RemindOperation_1 = require("../../../operation/RemindOperation");
+const RuleOperation_1 = require("../../../operation/RuleOperation");
+const PropertyOperation_1 = require("../../../operation/PropertyOperation");
+const PropertyID_1 = require("../../../xid/PropertyID");
+const ActionOperation_1 = require("../../../operation/ActionOperation");
+const ActionID_1 = require("../../../xid/ActionID");
+const ArgumentOperation_1 = require("../../../operation/ArgumentOperation");
+class OperationParser {
+    constructor() {
+        this.operations = [];
+        this.state = OperationState_1.OperationState.INIT;
+        this.iid = 0;
+    }
+    parseExpression(expression) {
+        return this.parseTokens(new Tokenizer_1.Tokenizer().parse(expression));
+    }
+    parseTokens(tokens) {
+        this.operations = new Array();
+        this.state = OperationState_1.OperationState.INIT;
+        while (tokens.length > 0) {
+            const token = tokens.shift();
+            if (token !== undefined && token !== null) {
+                this.parse(token);
+            }
+        }
+        return this.operations;
+    }
+    parse(token) {
+        switch (this.state) {
+            case OperationState_1.OperationState.INIT:
+                this.handleStateInit(token);
+                break;
+            case OperationState_1.OperationState.ID_XID3:
+                this.handleStateID_XID3(token);
+                break;
+            case OperationState_1.OperationState.ID_SLEEP:
+                this.handleStateID_SLEEP(token);
+                break;
+            case OperationState_1.OperationState.ID_REMIND:
+                this.handleStateID_REMIND(token);
+                break;
+            case OperationState_1.OperationState.ID_SCENE:
+                this.handleStateID_SCENE(token);
+                break;
+            case OperationState_1.OperationState.OP_SLEEP:
+                this.handleStateOP_SLEEP(token);
+                break;
+            case OperationState_1.OperationState.OP_REMIND:
+                this.handleStateOP_REMIND(token);
+                break;
+            case OperationState_1.OperationState.OP_XID:
+                this.handleStateOP_XID(token);
+                break;
+            case OperationState_1.OperationState.PROPERTY_VALUE:
+                this.handleStateProperty_Value(token);
+                break;
+            case OperationState_1.OperationState.ARGUMENT_VALUE:
+                this.handleStateArgument_Value(token);
+                break;
+            case OperationState_1.OperationState.SLEEP_VALUE:
+                this.handleStateSleep_Value(token);
+                break;
+            case OperationState_1.OperationState.REMIND_VALUE:
+                this.handleStateRemind_Value(token);
+                break;
+            case OperationState_1.OperationState.SEMICOLON:
+                this.handleStateSEMICOLON(token);
+                break;
+            case OperationState_1.OperationState.HASH:
+                this.handleStateHASH(token);
+                break;
+            case OperationState_1.OperationState.INTEGER:
+                this.handleStateInteger(token);
+                break;
+            case OperationState_1.OperationState.ASSIGN:
+                this.handleStateASSIGN(token);
+                break;
+            case OperationState_1.OperationState.COMMA:
+                this.handleStateCOMMA(token);
+                break;
+            default:
+                throw new Error('state undefined: ' + this.state);
+        }
+    }
+    handleStateInit(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this.parseXID(token);
+            this.state = OperationState_1.OperationState.ID_XID3;
+            return;
+        }
+        if (token.type === Token_1.TokenType.KEY_SLEEP) {
+            this.operation = new SleepOperation_1.SleepOperation();
+            this.state = OperationState_1.OperationState.ID_SLEEP;
+            return;
+        }
+        if (token.type === Token_1.TokenType.KEY_REMIND) {
+            this.operation = new RemindOperation_1.RemindOperation();
+            this.state = OperationState_1.OperationState.ID_REMIND;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this.operation = new RuleOperation_1.RuleOperation(token.getString());
+            this.state = OperationState_1.OperationState.ID_SCENE;
+            return;
+        }
+        throw new Error('state is INIT, token expected is ID, but token is ' + token.type + ': ' + token);
+    }
+    handleStateID_XID3(token) {
+        if (token.type === Token_1.TokenType.OPERATE) {
+            this.state = OperationState_1.OperationState.OP_XID;
+            return;
+        }
+        throw new Error('state is ID_XID, token expected is \'=>\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateID_SLEEP(token) {
+        if (token.type === Token_1.TokenType.OPERATE) {
+            this.state = OperationState_1.OperationState.OP_SLEEP;
+            return;
+        }
+        throw new Error('state is ID_SLEEP, token expected is \'=>\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateID_REMIND(token) {
+        if (token.type === Token_1.TokenType.OPERATE) {
+            this.state = OperationState_1.OperationState.OP_REMIND;
+            return;
+        }
+        throw new Error('state is ID_REMIND, token expected is \'=>\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateID_SCENE(token) {
+        if (token.type === Token_1.TokenType.SEMICOLON) {
+            if (this.operation === undefined) {
+                throw new Error('operation is undefined');
+            }
+            this.operations.push(this.operation);
+            this.state = OperationState_1.OperationState.SEMICOLON;
+            return;
+        }
+        throw new Error('state is ID_SCENE, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateOP_SLEEP(token) {
+        if (token.isValue()) {
+            if (this.operation instanceof SleepOperation_1.SleepOperation) {
+                const o = this.operation;
+                o.seconds = token.getInteger();
+                this.state = OperationState_1.OperationState.SLEEP_VALUE;
+            }
+            return;
+        }
+        throw new Error('state is OP_DELAY, token expected is Number, but token is ' + token.type + ': ' + token);
+    }
+    handleStateOP_REMIND(token) {
+        if (token.isValue()) {
+            if (this.operation instanceof RemindOperation_1.RemindOperation) {
+                const o = this.operation;
+                o.text = token.getString();
+                this.state = OperationState_1.OperationState.REMIND_VALUE;
+            }
+            return;
+        }
+        throw new Error('state is OP_DELAY, token expected is Number, but token is ' + token.type + ': ' + token);
+    }
+    handleStateOP_XID(token) {
+        if (token.isValue()) {
+            const o = new PropertyOperation_1.PropertyOperation();
+            if (this.xid === undefined) {
+                throw new Error('xid is undefined');
+            }
+            o.pid = PropertyID_1.PropertyID.create(this.xid.did, this.xid.siid, this.xid.iid);
+            o.value = token.getValue();
+            this.operation = o;
+            this.state = OperationState_1.OperationState.PROPERTY_VALUE;
+            return;
+        }
+        if (token.type === Token_1.TokenType.HASH) {
+            const o = new ActionOperation_1.ActionOperation();
+            if (this.xid === undefined) {
+                throw new Error('xid is undefined');
+            }
+            o.aid = ActionID_1.ActionID.create(this.xid.did, this.xid.siid, this.xid.iid);
+            this.operation = o;
+            this.state = OperationState_1.OperationState.HASH;
+            return;
+        }
+        throw new Error('state is OP_XID, token expected is value or #, but token is ' + token.type + ': ' + token);
+    }
+    handleStateProperty_Value(token) {
+        if (token.type === Token_1.TokenType.SEMICOLON) {
+            if (this.operation === undefined) {
+                throw new Error('operation is undefined');
+            }
+            this.operations.push(this.operation);
+            this.state = OperationState_1.OperationState.SEMICOLON;
+            return;
+        }
+        throw new Error('state is DELAY_VALUE, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateArgument_Value(token) {
+        if (token.type === Token_1.TokenType.SEMICOLON) {
+            if (this.operation === undefined) {
+                throw new Error('operation is undefined');
+            }
+            this.operations.push(this.operation);
+            this.state = OperationState_1.OperationState.SEMICOLON;
+            return;
+        }
+        if (token.type === Token_1.TokenType.COMMA) {
+            this.state = OperationState_1.OperationState.COMMA;
+            return;
+        }
+        throw new Error('state is ARGUMENT_VALUE, token expected is \';\' or \',\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateSleep_Value(token) {
+        if (token.type === Token_1.TokenType.SEMICOLON) {
+            if (this.operation === undefined) {
+                throw new Error('operation is undefined');
+            }
+            this.operations.push(this.operation);
+            this.state = OperationState_1.OperationState.INIT;
+            return;
+        }
+        throw new Error('state is SLEEP_VALUE, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateRemind_Value(token) {
+        if (token.type === Token_1.TokenType.SEMICOLON) {
+            if (this.operation === undefined) {
+                throw new Error('operation is undefined');
+            }
+            this.operations.push(this.operation);
+            this.state = OperationState_1.OperationState.INIT;
+            return;
+        }
+        throw new Error('state is REMIND_VALUE, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateSEMICOLON(token) {
+        this.handleStateInit(token);
+    }
+    handleStateHASH(token) {
+        if (this.operation instanceof ActionOperation_1.ActionOperation) {
+            const o = this.operation;
+            this.iid = token.getInteger();
+            o.in.set(this.iid, new ArgumentOperation_1.ArgumentOperation(this.iid));
+            this.state = OperationState_1.OperationState.INTEGER;
+            return;
+        }
+        throw new Error('state is #, token expected is Integer, but token is ' + token.type + ': ' + token);
+    }
+    handleStateInteger(token) {
+        if (token.type === Token_1.TokenType.ASSIGNMENT) {
+            this.state = OperationState_1.OperationState.ASSIGN;
+            return;
+        }
+        throw new Error('state is NUMBER, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateASSIGN(token) {
+        if (token.isValue()) {
+            if (this.operation instanceof ActionOperation_1.ActionOperation) {
+                const o = this.operation;
+                const a = o.in.get(this.iid);
+                if (a === undefined) {
+                    throw new Error(`state is ',', but argument is undefined. iid: ${this.iid}`);
+                }
+                a.values.push(token.getValue());
+                this.state = OperationState_1.OperationState.ARGUMENT_VALUE;
+            }
+            else {
+                throw new Error('state is \'=\', but operation not ActionOperation');
+            }
+            return;
+        }
+        throw new Error('state is NUMBER, token expected is \';\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateCOMMA(token) {
+        if (token.type === Token_1.TokenType.HASH) {
+            this.state = OperationState_1.OperationState.HASH;
+            return;
+        }
+        if (token.isValue()) {
+            if (this.operation instanceof ActionOperation_1.ActionOperation) {
+                const o = this.operation;
+                const a = o.in.get(this.iid);
+                if (a === undefined) {
+                    throw new Error(`state is ',', but argument is undefined. iid: ${this.iid}`);
+                }
+                a.values.push(token.getValue());
+                this.state = OperationState_1.OperationState.ARGUMENT_VALUE;
+            }
+            else {
+                throw new Error('state is \',\', but operation not ActionOperation');
+            }
+            return;
+        }
+        throw new Error('state is \',\', token expected is #, but token is ' + token.type + ': ' + token);
+    }
+    parseXID(token) {
+        const value = token.toString();
+        if (token.type !== Token_1.TokenType.XID3) {
+            throw new Error('表达式错误，token不是合法的ID: ' + value);
+        }
+        this.xid = new XID3_1.XID3(value);
+        if (!this.xid.valid) {
+            throw new Error('表达式错误，XID不合法: ' + value);
+        }
+    }
+    static toString(operations, pretty = true, tab = true) {
+        let str = '';
+        let i = 1;
+        const size = operations.length;
+        for (const operation of operations) {
+            str += operation.toString(pretty, tab);
+            if (i < size) {
+                if (pretty) {
+                    str += '\n';
+                }
+                else {
+                    str += ' ';
+                }
+            }
+            i++;
+        }
+        return str;
+    }
+}
+exports.OperationParser = OperationParser;

package/dist/xiot/core/spec/typedef/rule/parser/operation/OperationState.d.ts

@@ -0,0 +1,19 @@
+export declare enum OperationState {
+    INIT = 0,// initialize
+    ID_XID3 = 1,// pid or aid
+    ID_SLEEP = 2,// SLEEP
+    ID_REMIND = 3,// REMIND
+    ID_SCENE = 4,// scene id
+    OP_XID = 5,// operator for action or property: =>
+    OP_SLEEP = 6,// operator for SLEEP: =>
+    OP_REMIND = 7,// operator for REMIND: =>
+    SLEEP_VALUE = 8,// sleep value
+    REMIND_VALUE = 9,// remind value
+    PROPERTY_VALUE = 10,// property value
+    ARGUMENT_VALUE = 11,// argument value
+    HASH = 12,// #
+    INTEGER = 13,// integer
+    ASSIGN = 14,// =
+    SEMICOLON = 15,// ;
+    COMMA = 16
+}

package/dist/xiot/core/spec/typedef/rule/parser/operation/OperationState.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationState = void 0;
+var OperationState;
+(function (OperationState) {
+    OperationState[OperationState["INIT"] = 0] = "INIT";
+    OperationState[OperationState["ID_XID3"] = 1] = "ID_XID3";
+    OperationState[OperationState["ID_SLEEP"] = 2] = "ID_SLEEP";
+    OperationState[OperationState["ID_REMIND"] = 3] = "ID_REMIND";
+    OperationState[OperationState["ID_SCENE"] = 4] = "ID_SCENE";
+    OperationState[OperationState["OP_XID"] = 5] = "OP_XID";
+    OperationState[OperationState["OP_SLEEP"] = 6] = "OP_SLEEP";
+    OperationState[OperationState["OP_REMIND"] = 7] = "OP_REMIND";
+    OperationState[OperationState["SLEEP_VALUE"] = 8] = "SLEEP_VALUE";
+    OperationState[OperationState["REMIND_VALUE"] = 9] = "REMIND_VALUE";
+    OperationState[OperationState["PROPERTY_VALUE"] = 10] = "PROPERTY_VALUE";
+    OperationState[OperationState["ARGUMENT_VALUE"] = 11] = "ARGUMENT_VALUE";
+    OperationState[OperationState["HASH"] = 12] = "HASH";
+    OperationState[OperationState["INTEGER"] = 13] = "INTEGER";
+    OperationState[OperationState["ASSIGN"] = 14] = "ASSIGN";
+    OperationState[OperationState["SEMICOLON"] = 15] = "SEMICOLON";
+    OperationState[OperationState["COMMA"] = 16] = "COMMA";
+})(OperationState || (exports.OperationState = OperationState = {}));

package/dist/xiot/core/spec/typedef/rule/parser/token/Token.d.ts

@@ -0,0 +1,91 @@
+import { ArgumentOperation } from '../../../operation/ArgumentOperation';
+export declare enum TokenType {
+    KEY_IF = "KEY_IF",// IF
+    KEY_THEN = "KEY_THEN",// THEN
+    KEY_ENDIF = "KEY_ENDIF",// ENDIF
+    KEY_AND = "KEY_AND",// AND
+    KEY_SLEEP = "KEY_SLEEP",// SLEEP
+    KEY_REMIND = "KEY_REMIND",// REMIND
+    KEY_ANY = "KEY_ANY",// ANY
+    KEY_REVERSE = "KEY_REVERSE",// REVERSE
+    KEY_AUTOSCALING = "KEY_AUTOSCALING",// AUTOSCALING
+    XID3 = "XID3",// PropertyID, EventID
+    EXID = "EXID",// ExternalID
+    OPERATE = "OPERATE",// =>
+    NUMBER = "NUMBER",// number, integer or float
+    STRING = "STRING",// string
+    TRUE = "TRUE",// true
+    FALSE = "FALSE",// false
+    LEFT_PARENTHESES = "LEFT_PARENTHESES",// (
+    RIGHT_PARENTHESES = "RIGHT_PARENTHESES",// )
+    OP_AND = "OP_AND",// &&
+    OP_OR = "OP_OR",// ||
+    OP_EQUAL = "OP_EQUAL",// ==
+    OP_NOT_EQUAL = "OP_NOT_EQUAL",// !=
+    OP_GREATER = "OP_GREATER",// >
+    OP_GREATER_OR_EQUAL = "OP_GREATER_OR_EQUAL",// >=
+    OP_LESS = "OP_LESS",// <
+    OP_LESS_OR_EQUAL = "OP_LESS_OR_EQUAL",// <=
+    LEFT_BRACE = "LEFT_BRACE",// {
+    RIGHT_BRACE = "RIGHT_BRACE",// }
+    HASH = "HASH",// #
+    ASSIGNMENT = "ASSIGNMENT",// =
+    SEMICOLON = "SEMICOLON",// ;
+    COMMA = "COMMA",// ,
+    EVENT_VALUE = "EVENT_VALUE"
+}
+export declare class Token {
+    private _type;
+    private _bytes;
+    private _offset;
+    private _length;
+    readonly arguments: Map<number, ArgumentOperation>;
+    constructor(type: TokenType, offset: number, length: number, bytes?: Array<string>);
+    get type(): TokenType;
+    set type(value: TokenType);
+    get bytes(): Array<string>;
+    set bytes(value: Array<string>);
+    get offset(): number;
+    set offset(value: number);
+    get length(): number;
+    set length(value: number);
+    toString(): string;
+    /**
+     * 操作数: 数值
+     * @return boolean
+     */
+    isValue(): boolean;
+    /**
+     * 运算符优先级
+     * @return int
+     */
+    priority(): number;
+    /**
+     * 运算符
+     * @return boolean
+     */
+    isOperator(): boolean;
+    /**
+     * 操作数
+     * @return boolean
+     */
+    isOperand(): boolean;
+    /**
+     * 运算符：逻辑运算符
+     * @return boolean
+     */
+    isLogicalOperator(): boolean;
+    /**
+     * 运算符：比较运算符
+     * @return boolean
+     */
+    isComparisonOperator(): boolean;
+    /**
+     * 括号
+     * @return boolean
+     */
+    isParentheses(): boolean;
+    getInteger(): number;
+    getString(): string;
+    getValue(): Object;
+}