@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/image/ServiceImage.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceImage = void 0;
+const Service_1 = require("../instance/Service");
+const PropertyImage_1 = require("./PropertyImage");
+const ActionImage_1 = require("./ActionImage");
+const EventImage_1 = require("./EventImage");
+const DataFormat_1 = require("../definition/property/data/DataFormat");
+const Status_1 = require("../status/Status");
+class ServiceImage extends Service_1.Service {
+    static of(s) {
+        return new ServiceImage(s.iid, s.type, s.description, s.getProperties().map(x => PropertyImage_1.PropertyImage.copy(x)), s.getActions().map(x => ActionImage_1.ActionImage.of(x)), s.getEvents().map(x => EventImage_1.EventImage.of(x)));
+    }
+    constructor(iid, type, description, properties, actions, events) {
+        super(iid, type, description, properties, actions, events);
+    }
+    getProperties() {
+        return super
+            .getProperties()
+            .filter(x => x instanceof PropertyImage_1.PropertyImage)
+            .map(x => x);
+    }
+    getActions() {
+        return super
+            .getActions()
+            .filter(x => x instanceof ActionImage_1.ActionImage)
+            .map(x => x);
+    }
+    getEvents() {
+        return super
+            .getEvents()
+            .filter(x => x instanceof EventImage_1.EventImage)
+            .map(x => x);
+    }
+    tryRead(o) {
+        if (o.pid == null) {
+            return;
+        }
+        const p = this.properties.get(o.pid.iid);
+        if (p != null) {
+            if (p instanceof PropertyImage_1.PropertyImage) {
+                p.tryRead(o);
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'property not instanceof PropertyImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_NOT_FOUND;
+            o.description = 'property not found';
+        }
+    }
+    tryWrite(o, save) {
+        if (o.pid == null) {
+            return;
+        }
+        const p = this.properties.get(o.pid.iid);
+        if (p != null) {
+            if (p instanceof PropertyImage_1.PropertyImage) {
+                if (DataFormat_1.DataFormat.COMBINATION === p.format) {
+                    const members = o.value;
+                    for (const piid of p.members) {
+                        const value = members.get(piid);
+                        if (value === null || value === undefined) {
+                            o.status = Status_1.Status.PROPERTY_VALUE_INVALID;
+                            o.description = `property value is null: piid: ${piid}`;
+                            break;
+                        }
+                        const propertyItem = this.properties.get(piid);
+                        if (!(propertyItem === null || propertyItem === void 0 ? void 0 : propertyItem.trySetValue(value))) {
+                            o.status = Status_1.Status.PROPERTY_VALUE_INVALID;
+                            o.description = `property value invalid: piid: ${piid}, value: ${value}`;
+                            break;
+                        }
+                    }
+                    if (o.status >= 0) {
+                        o.status = Status_1.Status.COMPLETED;
+                    }
+                }
+                else {
+                    p.tryWrite(o, save);
+                }
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'property not instanceof PropertyImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_NOT_FOUND;
+            o.description = 'property not found';
+        }
+    }
+    tryInvoke(o) {
+        if (o.aid == null) {
+            return;
+        }
+        const a = this.actions.get(o.aid.iid);
+        if (a != null) {
+            if (a instanceof ActionImage_1.ActionImage) {
+                a.tryInvoke(o, this.properties);
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'action not instanceof ActionImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.ACTION_NOT_FOUND;
+            o.description = 'action not found';
+        }
+    }
+    tryEventOccurred(o) {
+        if (o.eid == null) {
+            return;
+        }
+        const e = this.events.get(o.eid.iid);
+        if (e != null) {
+            if (e instanceof EventImage_1.EventImage) {
+                e.tryEventOccurred(o, this.properties);
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'event not instanceof EventImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.EVENT_NOT_FOUND;
+            o.description = 'event not found';
+        }
+    }
+    update(o) {
+        if (o.pid == null) {
+            return;
+        }
+        const p = this.properties.get(o.pid.iid);
+        if (p != null) {
+            if (p instanceof PropertyImage_1.PropertyImage) {
+                p.update(o);
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'property not instanceof PropertyImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_NOT_FOUND;
+            o.description = 'property not found';
+        }
+    }
+    onPropertiesChanged(o) {
+        if (o.pid == null) {
+            return;
+        }
+        const p = this.properties.get(o.pid.iid);
+        if (p != null) {
+            if (p instanceof PropertyImage_1.PropertyImage) {
+                p.onPropertiesChanged(o);
+            }
+            else {
+                o.status = Status_1.Status.UNDEFINED;
+                o.description = 'property not instanceof PropertyImage';
+            }
+        }
+        else {
+            o.status = Status_1.Status.PROPERTY_NOT_FOUND;
+            o.description = 'property not found';
+        }
+    }
+}
+exports.ServiceImage = ServiceImage;

package/dist/xiot/core/spec/typedef/instance/Action.d.ts

@@ -0,0 +1,14 @@
+import { ActionType } from '../definition/urn/ActionType';
+import { Argument } from './Argument';
+export declare class Action {
+    iid: number;
+    type: ActionType;
+    description: Map<string, string>;
+    in: Map<number, Argument>;
+    out: Map<number, Argument>;
+    constructor(iid: number, type: ActionType, description: Map<string, string>, argumentsIn: Argument[], argumentsOut: Argument[]);
+    getArgumentsIn(): Argument[];
+    getArgumentsOut(): Argument[];
+    addArgumentIn(arg: Argument): void;
+    addArgumentOut(arg: Argument): void;
+}

package/dist/xiot/core/spec/typedef/instance/Action.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = void 0;
+class Action {
+    constructor(iid, type, description, argumentsIn, argumentsOut) {
+        this.iid = 0;
+        this.description = new Map();
+        this.in = new Map();
+        this.out = new Map();
+        this.iid = iid;
+        this.type = type;
+        this.description = description;
+        argumentsIn.forEach(x => {
+            return this.in.set(x.piid, x);
+        });
+        argumentsOut.forEach(x => {
+            return this.out.set(x.piid, x);
+        });
+    }
+    getArgumentsIn() {
+        return Array.from(this.in.values());
+    }
+    getArgumentsOut() {
+        return Array.from(this.out.values());
+    }
+    addArgumentIn(arg) {
+        this.in.set(arg.piid, arg);
+    }
+    addArgumentOut(arg) {
+        this.out.set(arg.piid, arg);
+    }
+}
+exports.Action = Action;

package/dist/xiot/core/spec/typedef/instance/Argument.d.ts

@@ -0,0 +1,8 @@
+export declare class Argument {
+    piid: number;
+    minRepeat: number;
+    maxRepeat: number;
+    values: any[];
+    constructor(piid: number);
+    static of(piid: number, minRepeat: number, maxRepeat: number): Argument;
+}

package/dist/xiot/core/spec/typedef/instance/Argument.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argument = void 0;
+class Argument {
+    constructor(piid) {
+        this.minRepeat = 1;
+        this.maxRepeat = 1;
+        this.values = [];
+        this.piid = piid;
+    }
+    static of(piid, minRepeat, maxRepeat) {
+        const arg = new Argument(piid);
+        arg.minRepeat = minRepeat;
+        arg.maxRepeat = maxRepeat;
+        return arg;
+    }
+}
+exports.Argument = Argument;

package/dist/xiot/core/spec/typedef/instance/DeviceInstance.d.ts

@@ -0,0 +1,9 @@
+import { Service } from './Service';
+import { Urn } from "../definition/urn/Urn";
+export declare class DeviceInstance {
+    type: Urn;
+    description: Map<string, string>;
+    services: Map<number, Service>;
+    constructor(type: Urn, description: Map<string, string>, services: Service[]);
+    getServices(): Service[];
+}

package/dist/xiot/core/spec/typedef/instance/DeviceInstance.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceInstance = void 0;
+class DeviceInstance {
+    constructor(type, description, services) {
+        this.type = type;
+        this.description = description;
+        this.services = new Map();
+        services.forEach(x => {
+            return this.services.set(x.iid, x);
+        });
+    }
+    getServices() {
+        return Array.from(this.services.values());
+    }
+}
+exports.DeviceInstance = DeviceInstance;

package/dist/xiot/core/spec/typedef/instance/Event.d.ts

@@ -0,0 +1,11 @@
+import { EventType } from '../definition/urn/EventType';
+import { Argument } from './Argument';
+export declare class Event {
+    iid: number;
+    type: EventType;
+    description: Map<string, string>;
+    arguments: Map<number, Argument>;
+    constructor(iid: number, type: EventType, description: Map<string, string>, list: Argument[]);
+    getArguments(): Argument[];
+    addArgument(arg: Argument): void;
+}

package/dist/xiot/core/spec/typedef/instance/Event.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+class Event {
+    constructor(iid, type, description, list) {
+        this.iid = 0;
+        this.description = new Map();
+        this.arguments = new Map();
+        this.iid = iid;
+        this.type = type;
+        this.description = description;
+        list.forEach(x => {
+            return this.arguments.set(x.piid, x);
+        });
+    }
+    getArguments() {
+        return Array.from(this.arguments.values());
+    }
+    addArgument(arg) {
+        this.arguments.set(arg.piid, arg);
+    }
+}
+exports.Event = Event;

package/dist/xiot/core/spec/typedef/instance/Property.d.ts

@@ -0,0 +1,56 @@
+import { PropertyValue } from './PropertyValue';
+import { DataFormat } from '../definition/property/data/DataFormat';
+import { Access } from '../definition/property/Access';
+import { ConstraintValue } from '../definition/property/ConstraintValue';
+import { PropertyType } from "../definition/urn/PropertyType";
+import { PropertyOperation } from "../operation/PropertyOperation";
+import { PropertyDefinition } from "../definition/PropertyDefinition";
+import { ValueRange } from "../definition/property/ValueRange";
+import { ValueList } from "../definition/property/ValueList";
+export declare class Property {
+    iid: number;
+    type: PropertyType;
+    description: Map<string, string>;
+    format: DataFormat;
+    access: Access;
+    constraintValue: ConstraintValue | null;
+    unit: string | null;
+    members: Array<number>;
+    value: PropertyValue;
+    static copy(other: Property): Property;
+    static of(iid: number, def: PropertyDefinition): Property;
+    constructor(iid: number | undefined, type: PropertyType, description: Map<string, string>, format: DataFormat, access: Access, constraintValue?: ConstraintValue | null, unit?: string | null, members?: Array<number>);
+    hasConstraintValue(): boolean;
+    hasValueRange(): boolean;
+    hasValueList(): boolean;
+    valueRange(): ValueRange | null;
+    valueList(): ValueList | null;
+    formatCombination(): boolean;
+    formatBoolean(): boolean;
+    formatString(): boolean;
+    formatNumber(): boolean;
+    setDefaultValue(value: any): void;
+    trySetValues(values: any[]): boolean;
+    trySetValue(value: Object): boolean;
+    setValue(value: Object): boolean;
+    setValueForOperation(o: PropertyOperation): void;
+    private setDataValue;
+    private setDataValueWithException;
+    private validate;
+    getValue(): any;
+    /**
+     * 忽略属性是否可写，给属性的成员赋值时，使用此接口给属性赋值。
+     * @param value 属性值
+     */
+    put(value: any): void;
+    /**
+     * 忽略属性是否可写，给属性的成员赋值时，使用此接口给属性赋值。
+     * @param value 属性值
+     */
+    putValue(value: any): void;
+    /**
+     * 构造组合属性值，由具体的组合属性实现，普通属性不需要实现。
+     */
+    valueOf(value: Map<number, any>): any | null;
+    toMap(value: any): Map<number, any>;
+}

package/dist/xiot/core/spec/typedef/instance/Property.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = void 0;
+const PropertyValue_1 = require("./PropertyValue");
+const DataValueFactory_1 = require("../definition/property/data/DataValueFactory");
+const DataFormat_1 = require("../definition/property/data/DataFormat");
+const IotError_1 = require("../error/IotError");
+const Status_1 = require("../status/Status");
+const ValueRange_1 = require("../definition/property/ValueRange");
+const ValueList_1 = require("../definition/property/ValueList");
+class Property {
+    static copy(other) {
+        const p = new Property(other.iid, other.type, other.description, other.format, other.access, other.constraintValue, other.unit, other.members);
+        p.value = PropertyValue_1.PropertyValue.copy(other.value);
+        return p;
+    }
+    static of(iid, def) {
+        return new Property(iid, def.type, def.description, def.format, def.access, def.constraintValue, def.unit, []);
+    }
+    constructor(iid = 0, type, description, format, access, constraintValue = null, unit = null, members = []) {
+        this.iid = iid;
+        this.type = type;
+        this.description = description;
+        this.format = format;
+        this.access = access;
+        this.constraintValue = constraintValue;
+        this.unit = unit;
+        this.members = members;
+        this.value = new PropertyValue_1.PropertyValue(this.format);
+    }
+    // fixDefaultValue(): void {
+    //   const list = this.valueList();
+    //   const range = this.valueRange();
+    //
+    //   if (list != null) {
+    //     const v: ValueDefinition = list.values[0];
+    //     if (v != null) {
+    //       this.value.currentValue = v.value;
+    //     }
+    //   } else if (range != null) {
+    //     const v = range.minValue;
+    //     if (v != null) {
+    //       this.value.currentValue = v;
+    //     }
+    //   }
+    // }
+    hasConstraintValue() {
+        return this.constraintValue != null;
+    }
+    hasValueRange() {
+        return this.constraintValue instanceof ValueRange_1.ValueRange;
+    }
+    hasValueList() {
+        return this.constraintValue instanceof ValueList_1.ValueList;
+    }
+    valueRange() {
+        if (this.constraintValue instanceof ValueRange_1.ValueRange) {
+            return this.constraintValue;
+        }
+        return null;
+    }
+    valueList() {
+        if (this.constraintValue instanceof ValueList_1.ValueList) {
+            return this.constraintValue;
+        }
+        return null;
+    }
+    formatCombination() {
+        return this.format == DataFormat_1.DataFormat.COMBINATION;
+    }
+    formatBoolean() {
+        return this.format == DataFormat_1.DataFormat.BOOL;
+    }
+    formatString() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.STRING:
+            case DataFormat_1.DataFormat.HEX:
+            case DataFormat_1.DataFormat.TLV8:
+                return true;
+            default:
+                return false;
+        }
+    }
+    formatNumber() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.FLOAT:
+            case DataFormat_1.DataFormat.UINT8:
+            case DataFormat_1.DataFormat.UINT16:
+            case DataFormat_1.DataFormat.UINT32:
+            case DataFormat_1.DataFormat.INT8:
+            case DataFormat_1.DataFormat.INT16:
+            case DataFormat_1.DataFormat.INT32:
+            case DataFormat_1.DataFormat.INT64:
+                return true;
+            default:
+                return false;
+        }
+    }
+    setDefaultValue(value) {
+        if (value != null) {
+            const v = DataValueFactory_1.DataValueFactory.create(this.format, value);
+            if (this.validate(v)) {
+                this.value.defaultValue = v;
+            }
+            else {
+                console.log("setDefaultValue error, validate failed!");
+            }
+        }
+    }
+    trySetValues(values) {
+        for (const o of values) {
+            if (!this.trySetValue(o)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    trySetValue(value) {
+        return this.setDataValue(value, false);
+    }
+    setValue(value) {
+        return this.setDataValue(value, true);
+    }
+    setValueForOperation(o) {
+        try {
+            this.setDataValueWithException(DataValueFactory_1.DataValueFactory.create(this.format, o.value), true);
+            o.status = Status_1.Status.COMPLETED;
+        }
+        catch (e) {
+            if (e instanceof IotError_1.IotError) {
+                o.status = e.status;
+                o.description = e.description;
+            }
+            else {
+                o.status = Status_1.Status.INTERNAL_ERROR;
+                o.description = 'undefined error';
+            }
+        }
+    }
+    setDataValue(newValue, write) {
+        if (newValue == null) {
+            console.log('setDataValue failed: newValue is null');
+            return false;
+        }
+        let v;
+        try {
+            v = DataValueFactory_1.DataValueFactory.create(this.format, newValue);
+        }
+        catch (e) {
+            console.log('DataValueFactory.create failed: newValue: ' + newValue + ', format: ' + this.format + ', iid: ' + this.iid + ' => ', e);
+            return false;
+        }
+        if (!this.validate(v)) {
+            console.log('setDataValue failed, validate failed: ', v);
+            return false;
+        }
+        if (this.value == null) {
+            console.log('setDataValue failed, property.value is null');
+            return false;
+        }
+        if (write) {
+            this.value.update(v);
+        }
+        return true;
+    }
+    setDataValueWithException(newValue, write) {
+        if (newValue == null) {
+            throw new IotError_1.IotError(Status_1.Status.PROPERTY_VALUE_ERROR, "property value is null");
+        }
+        if (!this.validate(newValue)) {
+            throw new IotError_1.IotError(Status_1.Status.PROPERTY_VALUE_INVALID, "property value invalid: " + newValue.rawValue());
+        }
+        if (write) {
+            this.value.update(newValue);
+        }
+    }
+    validate(value) {
+        if (value == null) {
+            console.log("property value validate failed, value is null");
+            return false;
+        }
+        if (this.format !== value.getFormat()) {
+            console.log(`validate failed, format not matched: ${this.format.toString()} != ${value.getFormat().toString()}`);
+            return false;
+        }
+        if (this.constraintValue == null) {
+            return true;
+        }
+        if (this.constraintValue.validate(value)) {
+            return true;
+        }
+        console.log('validate failed: ', `${this.constraintValue.toString()} invalid value: ${value.rawValue()}`);
+        return false;
+    }
+    getValue() {
+        if (this.format == DataFormat_1.DataFormat.COMBINATION) {
+            if (this.value.value().rawValue() instanceof Map) {
+                const v = this.value.value().rawValue();
+                return this.valueOf(v);
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return this.value.value().rawValue();
+        }
+    }
+    /**
+     * 忽略属性是否可写，给属性的成员赋值时，使用此接口给属性赋值。
+     * @param value 属性值
+     */
+    put(value) {
+        if (this.format == DataFormat_1.DataFormat.COMBINATION) {
+            if (!this.setValue(this.toMap(value))) {
+                throw new IotError_1.IotError(Status_1.Status.PROPERTY_VALUE_ERROR, "property value invalid");
+            }
+        }
+        else {
+            if (!this.setValue(value)) {
+                throw new IotError_1.IotError(Status_1.Status.PROPERTY_VALUE_ERROR, "property value invalid");
+            }
+        }
+    }
+    /**
+     * 忽略属性是否可写，给属性的成员赋值时，使用此接口给属性赋值。
+     * @param value 属性值
+     */
+    putValue(value) {
+        if (!this.setValue(value)) {
+            throw new IotError_1.IotError(Status_1.Status.PROPERTY_VALUE_ERROR, "property value invalid");
+        }
+    }
+    /**
+     * 构造组合属性值，由具体的组合属性实现，普通属性不需要实现。
+     */
+    valueOf(value) {
+        return null;
+    }
+    toMap(value) {
+        return new Map();
+    }
+}
+exports.Property = Property;

package/dist/xiot/core/spec/typedef/instance/PropertyValue.d.ts

@@ -0,0 +1,16 @@
+import { DataFormat } from '../definition/property/data/DataFormat';
+import { DataValue } from '../definition/property/data/DataValue';
+export declare class PropertyValue {
+    format: DataFormat;
+    initValue: DataValue<any>;
+    defaultValue: DataValue<any> | null;
+    currentValue: DataValue<any> | null;
+    static copy(o: PropertyValue): PropertyValue;
+    constructor(format: DataFormat);
+    update(newValue: DataValue<any>): void;
+    value(): DataValue<any>;
+    private refreshValueForDebuggerOrSimulator;
+    _stringValue: string;
+    _numberValue: number;
+    _booleanValue: boolean;
+}