@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vfloat.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vfloat = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vfloat {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vfloat();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vfloat();
+        v.value = Number.parseFloat(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vfloat)) {
+            return false;
+        }
+        return this.value < max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vfloat) || !(max instanceof Vfloat)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        if (this.value < minValue || this.value > maxValue) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vfloat) || !(max instanceof Vfloat) || !(step instanceof Vfloat)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v < maxValue; v += stepValue) {
+            if (Math.abs(v - this.value) < 0.00001) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.FLOAT;
+    }
+}
+exports.Vfloat = Vfloat;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vhex.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vhex implements DataValue<string> {
+    private value;
+    static create(value: Object): Vhex;
+    static fromString(value: string): Vhex;
+    equals(other: DataValue<string>): boolean;
+    lessEquals(max: DataValue<string>): boolean;
+    validate(min: DataValue<string>, max: DataValue<string>, step?: DataValue<string>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): string;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vhex.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vhex = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vhex {
+    constructor() {
+        this.value = '00';
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'string') {
+            const v = new Vhex();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vhex();
+        v.value = value;
+        return v;
+    }
+    equals(other) {
+        const thisValue = Number.parseInt(this.value, 16);
+        const otherValue = Number.parseInt(other.rawValue(), 16);
+        return thisValue === otherValue;
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vhex)) {
+            return false;
+        }
+        const thisValue = Number.parseInt(this.value, 16);
+        const maxValue = Number.parseInt(max.value, 16);
+        return thisValue <= maxValue;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vhex) || !(max instanceof Vhex)) {
+            console.log('validate failed, min & max not instanceof Vhex');
+            return false;
+        }
+        const thisValue = Number.parseInt(this.value, 16);
+        const minValue = Number.parseInt(min.value, 16);
+        const maxValue = Number.parseInt(max.value, 16);
+        if (thisValue < minValue) {
+            console.log(`this.Value(${this.value}) < minValue(${min.value})`);
+            return false;
+        }
+        if (thisValue > maxValue) {
+            console.log(`this.Value(${this.value}) > maxValue(${max.value})`);
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vhex) || !(max instanceof Vhex) || !(step instanceof Vhex)) {
+            console.log('validate failed, min & max & step not instanceof Vhex');
+            return false;
+        }
+        const thisValue = Number.parseInt(this.value, 16);
+        const minValue = Number.parseInt(min.value, 16);
+        const maxValue = Number.parseInt(max.value, 16);
+        const stepValue = Number.parseInt(step.value, 16);
+        for (let v = minValue; v < maxValue; v += stepValue) {
+            if (v === thisValue) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.HEX;
+    }
+}
+exports.Vhex = Vhex;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint16.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vint16 implements DataValue<number> {
+    private value;
+    static create(value: Object): Vint16;
+    static fromString(value: string): Vint16;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint16.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vint16 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vint16 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vint16();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vint16();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vint16)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vint16) || !(max instanceof Vint16)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vint16) || !(max instanceof Vint16) || !(step instanceof Vint16)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.INT16;
+    }
+}
+exports.Vint16 = Vint16;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint32.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vint32 implements DataValue<number> {
+    private value;
+    static create(value: Object): Vint32;
+    static fromString(value: string): Vint32;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint32.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vint32 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vint32 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vint32();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vint32();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vint32)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vint32) || !(max instanceof Vint32)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vint32) || !(max instanceof Vint32) || !(step instanceof Vint32)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.INT32;
+    }
+}
+exports.Vint32 = Vint32;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint64.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vint64 implements DataValue<number> {
+    private value;
+    static create(value: Object): Vint64;
+    static fromString(value: string): Vint64;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint64.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vint64 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vint64 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vint64();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vint64();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vint64)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vint64) || !(max instanceof Vint64)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vint64) || !(max instanceof Vint64) || !(step instanceof Vint64)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.INT64;
+    }
+}
+exports.Vint64 = Vint64;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint8.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vint8 implements DataValue<number> {
+    private value;
+    static create(value: Object): Vint8;
+    static fromString(value: string): Vint8;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    private validate2;
+    private validate3;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vint8.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vint8 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vint8 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vint8();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vint8();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vint8)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        if (!(min instanceof Vint8) || !(max instanceof Vint8)) {
+            return false;
+        }
+        if (this.value < min.value || this.value > max.value) {
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        if (!(min instanceof Vint8) || !(max instanceof Vint8) || !(step instanceof Vint8)) {
+            return false;
+        }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.INT8;
+    }
+}
+exports.Vint8 = Vint8;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vstring.d.ts

@@ -0,0 +1,11 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vstring implements DataValue<string> {
+    private value;
+    static create(value: Object): Vstring;
+    equals(other: DataValue<string>): boolean;
+    lessEquals(maxValue: DataValue<string>): boolean;
+    validate(min: DataValue<string>, max: DataValue<string>, step?: DataValue<string>): boolean;
+    rawValue(): string;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vstring.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vstring = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vstring {
+    constructor() {
+        this.value = '';
+    }
+    static create(value) {
+        const type = typeof value;
+        const v = new Vstring();
+        if (type === 'string') {
+            v.value = String(value);
+        }
+        else {
+            console.log(`invalid value: ${value} typeof(value): ${type}`);
+        }
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(maxValue) {
+        return false;
+    }
+    validate(min, max, step) {
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.STRING;
+    }
+}
+exports.Vstring = Vstring;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vtlv8.d.ts

@@ -0,0 +1,12 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vtlv8 implements DataValue<string> {
+    private value;
+    static create(value: Object): Vtlv8;
+    static fromString(value: string): Vtlv8;
+    equals(other: DataValue<string>): boolean;
+    lessEquals(maxValue: DataValue<string>): boolean;
+    validate(min: DataValue<string>, max: DataValue<string>, step?: DataValue<string>): boolean;
+    rawValue(): string;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vtlv8.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vtlv8 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vtlv8 {
+    constructor() {
+        this.value = '';
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'string') {
+            const v = new Vtlv8();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vtlv8();
+        v.value = value;
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(maxValue) {
+        return false;
+    }
+    validate(min, max, step) {
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.TLV8;
+    }
+}
+exports.Vtlv8 = Vtlv8;

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vuint16.d.ts

@@ -0,0 +1,14 @@
+import { DataValue } from '../DataValue';
+import { DataFormat } from '../DataFormat';
+export declare class Vuint16 implements DataValue<number> {
+    private value;
+    static create(value: Object): Vuint16;
+    static fromString(value: string): Vuint16;
+    equals(other: DataValue<number>): boolean;
+    lessEquals(max: DataValue<number>): boolean;
+    validate(min: DataValue<number>, max: DataValue<number>, step?: DataValue<number>): boolean;
+    validate2(min: DataValue<number>, max: DataValue<number>): boolean;
+    validate3(min: DataValue<number>, max: DataValue<number>, step: DataValue<number> | null): boolean;
+    rawValue(): number;
+    getFormat(): DataFormat;
+}

package/dist/xiot/core/spec/typedef/definition/property/data/value/Vuint16.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vuint16 = void 0;
+const DataFormat_1 = require("../DataFormat");
+class Vuint16 {
+    constructor() {
+        this.value = 0;
+    }
+    static create(value) {
+        const type = typeof value;
+        if (type === 'number') {
+            const v = new Vuint16();
+            v.value = value;
+            return v;
+        }
+        throw new Error(`invalid value: ${value} typeof(value): ${type}`);
+    }
+    static fromString(value) {
+        const v = new Vuint16();
+        v.value = Number.parseInt(value);
+        return v;
+    }
+    equals(other) {
+        return this.value === other.rawValue();
+    }
+    lessEquals(max) {
+        if (!(max instanceof Vuint16)) {
+            return false;
+        }
+        return this.value <= max.value;
+    }
+    validate(min, max, step) {
+        return step ? this.validate3(min, max, step) : this.validate2(min, max);
+    }
+    validate2(min, max) {
+        // if (!(min instanceof Vuint16) || !(max instanceof Vuint16)) {
+        //   console.log('validate failed, minValue is null');
+        //   return false;
+        // }
+        if (this.value < min.value) {
+            console.log(`validate failed, ${this.value} < minValue(${min.value})`);
+            return false;
+        }
+        if (this.value > max.value) {
+            console.log(`validate failed, ${this.value} > maxValue(${max.value})`);
+            return false;
+        }
+        return true;
+    }
+    validate3(min, max, step) {
+        // if (!(min instanceof Vuint16) || !(max instanceof Vuint16) || !(step instanceof Vuint16)) {
+        //   return false;
+        // }
+        const minValue = min.value;
+        const maxValue = max.value;
+        const stepValue = step.value;
+        for (let v = minValue; v <= maxValue; v += stepValue) {
+            if (v === this.value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    rawValue() {
+        return this.value;
+    }
+    getFormat() {
+        return DataFormat_1.DataFormat.UINT16;
+    }
+}
+exports.Vuint16 = Vuint16;