@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser1/Parser1.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser1 = void 0;
+const Stack_1 = require("../../../../utils/Stack");
+const Token_1 = require("../../token/Token");
+const Parser0_1 = require("../parser0/Parser0");
+class Parser1 {
+    /**
+     * 将表达式转为逆波兰表达式
+     * @param expression 表达式
+     * @return stack 逆波兰表达式
+     */
+    static parse(expression) {
+        return this.parseTokens(new Parser0_1.Parser0().parse(expression));
+    }
+    /**
+     * https://www.fatalerrors.org/index.php/a/prefix-suffix-suffix-expression-inverse-polish-expression.html
+     * @param tokens 表达式
+     * @return stack 逆波兰表达式
+     */
+    static parseTokens(tokens) {
+        // 1 初始化2个栈：运算符栈s1和存储中间结果的栈s2
+        const s1 = new Stack_1.Stack(), s2 = new Stack_1.Stack();
+        while (tokens.length > 0) {
+            // 2 从左到右扫描中缀表达式
+            const token = tokens.shift();
+            if (token === undefined) {
+                continue;
+            }
+            // 3 遇到操作数，压入s2
+            if (token.isOperand()) {
+                s2.push(token);
+                continue;
+            }
+            // 4 遇到运算符, 比较其与s1栈顶运算符的优先级
+            if (token.isOperator()) {
+                while (true) {
+                    // 4.1 如果s1为空，或栈顶运算符为左括号'('，则直接将此运算符入栈
+                    if (s1.empty() || s1.peek().type === Token_1.TokenType.LEFT_PARENTHESES) {
+                        s1.push(token);
+                        break;
+                    }
+                    else if (token.priority() > s1.peek().priority()) {
+                        s1.push(token);
+                        break;
+                    }
+                    // 4.3 否则，将s1栈顶的运算符弹出并压入到s2中，再次转入4.1
+                    const t = s1.pop();
+                    if (t !== undefined) {
+                        s2.push(t);
+                    }
+                }
+                continue;
+            }
+            // 5 遇到括号
+            if (token.isParentheses()) {
+                // 5.1 如果是左括号'('，则直接压入s1
+                if (token.type === Token_1.TokenType.LEFT_PARENTHESES) {
+                    s1.push(token);
+                    continue;
+                }
+                // 5.2 如果是右括号')'，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号'('为止，此时将这一对括号丢弃
+                if (token.type === Token_1.TokenType.RIGHT_PARENTHESES) {
+                    while (s1.size() > 0) {
+                        const t = s1.pop();
+                        if (t === undefined) {
+                            continue;
+                        }
+                        if (t.type === Token_1.TokenType.LEFT_PARENTHESES) {
+                            break;
+                        }
+                        s2.push(t);
+                    }
+                }
+            }
+        }
+        // 7 将s1剩余的运算符依次弹出并压入s2
+        while (s1.size() > 0) {
+            const t = s1.pop();
+            if (t === undefined) {
+                continue;
+            }
+            s2.push(t);
+        }
+        // 8 依次弹出s2中的元素，结果的逆序即为中缀表达式对应的后缀表达式
+        s2.reverse();
+        return s2;
+    }
+}
+exports.Parser1 = Parser1;

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/Parser2.d.ts

@@ -0,0 +1,31 @@
+import { Stack } from '../../../../utils/Stack';
+import { Token2 } from './Token2';
+import { Token } from '../../token/Token';
+export declare class Parser2 {
+    private _stack;
+    private _state;
+    private _id1;
+    private _id2;
+    private _value;
+    /**
+     * 将一阶逆波兰表达式加工成二阶逆波兰表达式
+     *
+     * @param tokens 一阶逆波兰表达式
+     * @return token2 二阶逆波兰表达式
+     */
+    parseTokens(tokens: Stack<Token>): Stack<Token2>;
+    private parseToken;
+    private handleStateInit;
+    private handleStateID1;
+    private handleStateID2;
+    private handleStateP_V;
+    private handleStateEX_V;
+    private handleStateP_C;
+    private handleStateEX_ID;
+    private handleStateEX_C;
+    private handleStateEVENT_C;
+    private handleStateEVENT_V;
+    private handleStateL;
+    private static getEventId;
+    private static getPropertyId;
+}

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/Parser2.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser2 = void 0;
+const Stack_1 = require("../../../../utils/Stack");
+const Token2_1 = require("./Token2");
+const ParserState2_1 = require("./ParserState2");
+const Token_1 = require("../../token/Token");
+const ComparisonOperator_1 = require("../../../condition/operator/ComparisonOperator");
+const PropertyCondition_1 = require("../../../condition/PropertyCondition");
+const ExternalType_1 = require("../../../condition/ExternalType");
+const NowCondition_1 = require("../../../condition/NowCondition");
+const TimeCondition_1 = require("../../../condition/TimeCondition");
+const ExternalCondition_1 = require("../../../condition/ExternalCondition");
+const EventCondition_1 = require("../../../condition/EventCondition");
+const EventID_1 = require("../../../../xid/EventID");
+const PropertyID_1 = require("../../../../xid/PropertyID");
+class Parser2 {
+    constructor() {
+        this._stack = new Stack_1.Stack();
+        this._state = ParserState2_1.ParserState2.INIT;
+    }
+    /**
+     * 将一阶逆波兰表达式加工成二阶逆波兰表达式
+     *
+     * @param tokens 一阶逆波兰表达式
+     * @return token2 二阶逆波兰表达式
+     */
+    parseTokens(tokens) {
+        this._stack = new Stack_1.Stack();
+        this._state = ParserState2_1.ParserState2.INIT;
+        while (tokens.size() > 0) {
+            const token = tokens.pop();
+            if (token === undefined) {
+                continue;
+            }
+            this.parseToken(token);
+        }
+        this._stack.reverse();
+        return this._stack;
+    }
+    parseToken(token) {
+        switch (this._state) {
+            case ParserState2_1.ParserState2.INIT:
+                this.handleStateInit(token);
+                break;
+            case ParserState2_1.ParserState2.ID1:
+                this.handleStateID1(token);
+                break;
+            case ParserState2_1.ParserState2.ID2:
+                this.handleStateID2(token);
+                break;
+            case ParserState2_1.ParserState2.EX_ID:
+                this.handleStateEX_ID(token);
+                break;
+            case ParserState2_1.ParserState2.P_V:
+                this.handleStateP_V(token);
+                break;
+            case ParserState2_1.ParserState2.EX_V:
+                this.handleStateEX_V(token);
+                break;
+            case ParserState2_1.ParserState2.EVENT_V:
+                this.handleStateEVENT_V(token);
+                break;
+            case ParserState2_1.ParserState2.P_C:
+                this.handleStateP_C(token);
+                break;
+            case ParserState2_1.ParserState2.EX_C:
+                this.handleStateEX_C(token);
+                break;
+            case ParserState2_1.ParserState2.EVENT_C:
+                this.handleStateEVENT_C(token);
+                break;
+            case ParserState2_1.ParserState2.L:
+                this.handleStateL(token);
+                break;
+            default:
+                throw new Error('state undefined: ' + this._state);
+        }
+    }
+    handleStateInit(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.ID1;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.EX_ID;
+            return;
+        }
+        throw new Error('state is INIT, token expected is ID, but token is ' + token.type + ': ' + token);
+    }
+    handleStateID1(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id2 = token;
+            this._state = ParserState2_1.ParserState2.ID2;
+            return;
+        }
+        if (token.isValue()) {
+            this._value = token;
+            this._state = ParserState2_1.ParserState2.P_V;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EVENT_VALUE) {
+            this._value = token;
+            this._state = ParserState2_1.ParserState2.EVENT_V;
+            return;
+        }
+        throw new Error('state is P1, token expected is ID or Value, but token is ' + token.type + ': ' + token);
+    }
+    handleStateID2(token) {
+        if (token.isComparisonOperator()) {
+            const operator = (0, ComparisonOperator_1.getComparisonOperator)(token.toString());
+            this._stack.push(Token2_1.Token2.createWithCondition(new PropertyCondition_1.PropertyCondition(Parser2.getPropertyId(this._id1), Parser2.getPropertyId(this._id2), operator)));
+            this._state = ParserState2_1.ParserState2.P_C;
+            this._id1 = undefined;
+            this._id2 = undefined;
+            return;
+        }
+        throw new Error('state is P2, token expected is ComparisonOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateP_V(token) {
+        if (this._value === undefined) {
+            throw new Error('Parser2: value is undefined');
+        }
+        if (token.isComparisonOperator()) {
+            const operator = (0, ComparisonOperator_1.getComparisonOperator)(token.toString());
+            this._stack.push(Token2_1.Token2.createWithCondition(new PropertyCondition_1.PropertyCondition(Parser2.getPropertyId(this._id1), this._value.getValue(), operator)));
+            this._state = ParserState2_1.ParserState2.P_C;
+            this._id1 = undefined;
+            this._value = undefined;
+            return;
+        }
+        throw new Error('state is P_V, token expected is ComparisonOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateEX_V(token) {
+        if (this._value === undefined) {
+            throw new Error('Parser2: value is undefined');
+        }
+        if (this._id1 === undefined) {
+            throw new Error('Parser2: _id1 is undefined');
+        }
+        if (token.isComparisonOperator()) {
+            const operator = (0, ComparisonOperator_1.getComparisonOperator)(token.toString());
+            let condition;
+            switch (this._id1.toString()) {
+                case ExternalType_1.ExternalType.NOW:
+                    condition = new NowCondition_1.NowCondition(this._value.getValue().toString());
+                    break;
+                case ExternalType_1.ExternalType.TIME:
+                    condition = new TimeCondition_1.TimeCondition(this._value.getValue().toString());
+                    break;
+                default:
+                    condition = new ExternalCondition_1.ExternalCondition(this._id1.toString(), this._value.getValue(), operator);
+                    break;
+            }
+            this._stack.push(Token2_1.Token2.createWithCondition(condition));
+            this._state = ParserState2_1.ParserState2.EX_C;
+            this._id1 = undefined;
+            this._value = undefined;
+            return;
+        }
+        throw new Error('state is EX_V, token expected is ComparisonOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateP_C(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.ID1;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.EX_ID;
+            return;
+        }
+        if (token.isLogicalOperator()) {
+            this._stack.push(new Token2_1.Token2(Token2_1.Token2Type.LOGICAL_OPERATOR, token.toString()));
+            this._state = ParserState2_1.ParserState2.L;
+            return;
+        }
+        throw new Error('state is P_C, token expected is ID or LogicalOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateEX_ID(token) {
+        if (token.isValue()) {
+            this._value = token;
+            this._state = ParserState2_1.ParserState2.EX_V;
+            return;
+        }
+        throw new Error('state is EX_ID, token expected is EX_V, but token is ' + token.type + ': ' + token);
+    }
+    handleStateEX_C(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.ID1;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.EX_ID;
+            return;
+        }
+        if (token.isLogicalOperator()) {
+            this._stack.push(new Token2_1.Token2(Token2_1.Token2Type.LOGICAL_OPERATOR, token.toString()));
+            this._state = ParserState2_1.ParserState2.L;
+            return;
+        }
+        throw new Error('state is EX_C, token expected is ID or LogicalOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateEVENT_C(token) {
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.ID1;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.EX_ID;
+            return;
+        }
+        if (token.isLogicalOperator()) {
+            this._stack.push(new Token2_1.Token2(Token2_1.Token2Type.LOGICAL_OPERATOR, token.toString()));
+            this._state = ParserState2_1.ParserState2.L;
+            return;
+        }
+        throw new Error('state is EX_C, token expected is ID or LogicalOperator, but token is ' + token.type + ': ' + token);
+    }
+    handleStateEVENT_V(token) {
+        if (token.type === Token_1.TokenType.OP_EQUAL) {
+            const condition = new EventCondition_1.EventCondition(Parser2.getEventId(this._id1));
+            if (this._value === undefined) {
+                throw new Error('Parser2: value is undefined');
+            }
+            condition.arguments = this._value.arguments;
+            this._stack.push(Token2_1.Token2.createWithCondition(condition));
+            this._state = ParserState2_1.ParserState2.EVENT_C;
+            this._id1 = undefined;
+            this._value = undefined;
+            return;
+        }
+        throw new Error('state is EVENT_V, token expected is \'==\', but token is ' + token.type + ': ' + token);
+    }
+    handleStateL(token) {
+        if (token.isLogicalOperator()) {
+            this._stack.push(new Token2_1.Token2(Token2_1.Token2Type.LOGICAL_OPERATOR, token.toString()));
+            this._state = ParserState2_1.ParserState2.L;
+            return;
+        }
+        if (token.type === Token_1.TokenType.XID3) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.ID1;
+            return;
+        }
+        if (token.type === Token_1.TokenType.EXID) {
+            this._id1 = token;
+            this._state = ParserState2_1.ParserState2.EX_ID;
+            return;
+        }
+        throw new Error('state is L, token expected is LogicalOperator or ID, but token is ' + token.type + ': ' + token);
+    }
+    static getEventId(token) {
+        if (token === undefined) {
+            throw new Error('Parser2: token is undefined');
+        }
+        const value = token.toString();
+        if (token.type !== Token_1.TokenType.XID3) {
+            throw new Error('表达式错误，token不是合法的ID: ' + value);
+        }
+        const eid = new EventID_1.EventID(value);
+        if (!eid.valid) {
+            throw new Error('表达式错误，EID不合法: ' + value);
+        }
+        return eid;
+    }
+    static getPropertyId(token) {
+        if (token === undefined) {
+            throw new Error('Parser2: token is undefined');
+        }
+        const value = token.toString();
+        if (token.type !== Token_1.TokenType.XID3) {
+            throw new Error('表达式错误，token不是合法的ID: ' + value);
+        }
+        const pid = new PropertyID_1.PropertyID(value);
+        if (!pid.valid) {
+            throw new Error('表达式错误，PID不合法: ' + value);
+        }
+        return pid;
+    }
+}
+exports.Parser2 = Parser2;

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/ParserState2.d.ts

@@ -0,0 +1,13 @@
+export declare enum ParserState2 {
+    INIT = 0,// initialize
+    ID1 = 1,// property id 1 or event id
+    ID2 = 2,// property id 2
+    EX_ID = 3,// external Id
+    P_V = 4,// property value
+    EX_V = 5,// external value
+    EVENT_V = 6,// event value
+    P_C = 7,// comparison operator for property
+    EX_C = 8,// comparison operator for external
+    EVENT_C = 9,// comparison operator for event
+    L = 10
+}

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/ParserState2.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserState2 = void 0;
+var ParserState2;
+(function (ParserState2) {
+    ParserState2[ParserState2["INIT"] = 0] = "INIT";
+    ParserState2[ParserState2["ID1"] = 1] = "ID1";
+    ParserState2[ParserState2["ID2"] = 2] = "ID2";
+    ParserState2[ParserState2["EX_ID"] = 3] = "EX_ID";
+    ParserState2[ParserState2["P_V"] = 4] = "P_V";
+    ParserState2[ParserState2["EX_V"] = 5] = "EX_V";
+    ParserState2[ParserState2["EVENT_V"] = 6] = "EVENT_V";
+    ParserState2[ParserState2["P_C"] = 7] = "P_C";
+    ParserState2[ParserState2["EX_C"] = 8] = "EX_C";
+    ParserState2[ParserState2["EVENT_C"] = 9] = "EVENT_C";
+    ParserState2[ParserState2["L"] = 10] = "L";
+})(ParserState2 || (exports.ParserState2 = ParserState2 = {}));

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/Token2.d.ts

@@ -0,0 +1,22 @@
+import { AbstractCondition } from '../../../condition/AbstractCondition';
+export declare enum Token2Type {
+    PROPERTY_CONDITION = 0,
+    EXTERNAL_CONDITION = 1,
+    EVENT_CONDITION = 2,
+    COMPARISON_OPERATOR = 3,
+    LOGICAL_OPERATOR = 4
+}
+export declare class Token2 {
+    private _type;
+    private _condition;
+    private _operator;
+    static createWithCondition(condition: AbstractCondition): Token2;
+    constructor(type: Token2Type | undefined, operator: string);
+    get type(): Token2Type;
+    set type(value: Token2Type);
+    get condition(): AbstractCondition;
+    set condition(value: AbstractCondition);
+    get operator(): string;
+    set operator(value: string);
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/rule/parser/condition/parser2/Token2.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token2 = exports.Token2Type = void 0;
+const PropertyCondition_1 = require("../../../condition/PropertyCondition");
+const EventCondition_1 = require("../../../condition/EventCondition");
+const ExternalCondition_1 = require("../../../condition/ExternalCondition");
+var Token2Type;
+(function (Token2Type) {
+    Token2Type[Token2Type["PROPERTY_CONDITION"] = 0] = "PROPERTY_CONDITION";
+    Token2Type[Token2Type["EXTERNAL_CONDITION"] = 1] = "EXTERNAL_CONDITION";
+    Token2Type[Token2Type["EVENT_CONDITION"] = 2] = "EVENT_CONDITION";
+    Token2Type[Token2Type["COMPARISON_OPERATOR"] = 3] = "COMPARISON_OPERATOR";
+    Token2Type[Token2Type["LOGICAL_OPERATOR"] = 4] = "LOGICAL_OPERATOR";
+})(Token2Type || (exports.Token2Type = Token2Type = {}));
+class Token2 {
+    static createWithCondition(condition) {
+        let typ;
+        if (condition instanceof PropertyCondition_1.PropertyCondition) {
+            typ = Token2Type.PROPERTY_CONDITION;
+        }
+        else if (condition instanceof EventCondition_1.EventCondition) {
+            typ = Token2Type.EVENT_CONDITION;
+        }
+        else if (condition instanceof ExternalCondition_1.ExternalCondition) {
+            typ = Token2Type.EXTERNAL_CONDITION;
+        }
+        const token = new Token2(typ, '');
+        token.condition = condition;
+        return token;
+    }
+    constructor(type, operator) {
+        this._type = type;
+        this._operator = operator;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    get condition() {
+        return this._condition;
+    }
+    set condition(value) {
+        this._condition = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    toString() {
+        switch (this.type) {
+            case Token2Type.PROPERTY_CONDITION:
+            case Token2Type.EVENT_CONDITION:
+                return this.condition.toString();
+            case Token2Type.EXTERNAL_CONDITION:
+                return '@' + this.condition.toString();
+            case Token2Type.COMPARISON_OPERATOR:
+            case Token2Type.LOGICAL_OPERATOR:
+                return this.operator;
+            default:
+                return '?';
+        }
+    }
+}
+exports.Token2 = Token2;

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

@@ -0,0 +1,31 @@
+import { AbstractOperation } from '../../../operation/AbstractOperation';
+import { Token } from '../token/Token';
+export declare class OperationParser {
+    private operations;
+    private state;
+    private operation;
+    private xid;
+    private iid;
+    parseExpression(expression: string): Array<AbstractOperation>;
+    parseTokens(tokens: Array<Token>): Array<AbstractOperation>;
+    private parse;
+    private handleStateInit;
+    private handleStateID_XID3;
+    private handleStateID_SLEEP;
+    private handleStateID_REMIND;
+    private handleStateID_SCENE;
+    private handleStateOP_SLEEP;
+    private handleStateOP_REMIND;
+    private handleStateOP_XID;
+    private handleStateProperty_Value;
+    private handleStateArgument_Value;
+    private handleStateSleep_Value;
+    private handleStateRemind_Value;
+    private handleStateSEMICOLON;
+    private handleStateHASH;
+    private handleStateInteger;
+    private handleStateASSIGN;
+    private handleStateCOMMA;
+    private parseXID;
+    static toString(operations: Array<AbstractOperation>, pretty?: boolean, tab?: boolean): string;
+}