@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/support/codegen/codec/controller/PropertyControllerCodec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyControllerCodec = void 0;
+const PropertyController_1 = require("../../typedef/controller/PropertyController");
+const PropertyCodec_1 = require("../../../../spec/codec/instance/PropertyCodec");
+class PropertyControllerCodec {
+    PropertyControllerCodec() {
+    }
+    static decodeArray(array) {
+        const properties = [];
+        if (array != null) {
+            for (let item of array) {
+                properties.push(this.decodeObject(item));
+            }
+        }
+        return properties;
+    }
+    static decodeObject(object) {
+        return new PropertyController_1.PropertyController(PropertyCodec_1.PropertyCodec.decode(object));
+    }
+    static encode(property) {
+        return PropertyCodec_1.PropertyCodec.encode(property);
+    }
+}
+exports.PropertyControllerCodec = PropertyControllerCodec;

package/dist/xiot/core/support/codegen/codec/controller/ServiceControllerCodec.d.ts

@@ -0,0 +1,5 @@
+import { ServiceController } from "../../typedef/controller/ServiceController";
+export declare class ServiceControllerCodec {
+    private static decodeObject;
+    static decodeArray(array: any[]): ServiceController[];
+}

package/dist/xiot/core/support/codegen/codec/controller/ServiceControllerCodec.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceControllerCodec = void 0;
+const ServiceController_1 = require("../../typedef/controller/ServiceController");
+const Spec_1 = require("../../../../spec/typedef/constant/Spec");
+const DescriptionCodec_1 = require("../../../../spec/codec/definition/DescriptionCodec");
+const ServiceType_1 = require("../../../../spec/typedef/definition/urn/ServiceType");
+const PropertyControllerCodec_1 = require("./PropertyControllerCodec");
+const EventControllerCodec_1 = require("./EventControllerCodec");
+const ActionControllerCodec_1 = require("./ActionControllerCodec");
+class ServiceControllerCodec {
+    static decodeObject(o) {
+        const iid = o[Spec_1.Spec.IID] || 0;
+        const type = ServiceType_1.ServiceType.parse(o[Spec_1.Spec.TYPE]);
+        const description = DescriptionCodec_1.DescriptionCodec.decode(o[Spec_1.Spec.DESCRIPTION]);
+        const properties = PropertyControllerCodec_1.PropertyControllerCodec.decodeArray(o[Spec_1.Spec.PROPERTIES]);
+        const actions = ActionControllerCodec_1.ActionControllerCodec.decodeArray(o[Spec_1.Spec.ACTIONS]);
+        const events = EventControllerCodec_1.EventControllerCodec.decodeArray(o[Spec_1.Spec.EVENTS]);
+        return new ServiceController_1.ServiceController(iid, type, description, properties, actions, events);
+    }
+    static decodeArray(array) {
+        const services = [];
+        if (array != null) {
+            for (let item of array) {
+                services.push(ServiceControllerCodec.decodeObject(item));
+            }
+        }
+        return services;
+    }
+}
+exports.ServiceControllerCodec = ServiceControllerCodec;

package/dist/xiot/core/support/codegen/typedef/controlled/ActionControlled.d.ts

@@ -0,0 +1,9 @@
+import { Action } from "../../../../spec/typedef/instance/Action";
+import { ActionOperation } from "../../../../spec/typedef/operation/ActionOperation";
+import { ActionType } from "../../../../spec/typedef/definition/urn/ActionType";
+import { Argument } from "../../../../spec/typedef/instance/Argument";
+export declare class ActionControlled extends Action {
+    private invoker;
+    constructor(iid: number, type: ActionType, description: Map<string, string>, argumentsIn: Argument[], argumentsOut: Argument[]);
+    invoke(action: ActionOperation): Promise<ActionOperation>;
+}

package/dist/xiot/core/support/codegen/typedef/controlled/ActionControlled.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionControlled = void 0;
+const Action_1 = require("../../../../spec/typedef/instance/Action");
+const Status_1 = require("../../../../spec/typedef/status/Status");
+class ActionControlled extends Action_1.Action {
+    constructor(iid, type, description, argumentsIn, argumentsOut) {
+        super(iid, type, description, argumentsIn, argumentsOut);
+    }
+    invoke(action) {
+        console.debug("invoke: " + action);
+        if (this.invoker != null) {
+            return this.invoker(action);
+        }
+        else {
+            console.error("invoke failed, invoker not implemented");
+            action.status = Status_1.Status.INTERNAL_ERROR;
+            action.description = "not implemented";
+            return new Promise((resolve, reject) => {
+                resolve(action);
+            });
+        }
+    }
+}
+exports.ActionControlled = ActionControlled;

package/dist/xiot/core/support/codegen/typedef/controlled/DeviceControlled.d.ts

@@ -0,0 +1,3 @@
+import { DeviceInstance } from "../../../../spec/typedef/instance/DeviceInstance";
+export declare class DeviceControlled extends DeviceInstance {
+}

package/dist/xiot/core/support/codegen/typedef/controlled/DeviceControlled.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceControlled = void 0;
+const DeviceInstance_1 = require("../../../../spec/typedef/instance/DeviceInstance");
+class DeviceControlled extends DeviceInstance_1.DeviceInstance {
+}
+exports.DeviceControlled = DeviceControlled;

package/dist/xiot/core/support/codegen/typedef/controlled/EventControlled.d.ts

@@ -0,0 +1,12 @@
+import { Event } from "../../../../spec/typedef/instance/Event";
+import { EventType } from "../../../../spec/typedef/definition/urn/EventType";
+import { Argument } from "../../../../spec/typedef/instance/Argument";
+import { EventOperation } from "../../../../spec/typedef/operation/EventOperation";
+import { EventID } from "../../../../spec/typedef/xid/EventID";
+import { ArgumentOperation } from "../../../../spec/typedef/operation/ArgumentOperation";
+export declare class EventControlled extends Event {
+    protected observers: Map<String, ((eid: EventID, list: ArgumentOperation[]) => void)>;
+    constructor(iid: number, type: EventType, description: Map<string, string>, list: Argument[]);
+    addObserver(observer: ((eid: EventID, list: ArgumentOperation[]) => void)): void;
+    doOccurred(o: EventOperation): void;
+}

package/dist/xiot/core/support/codegen/typedef/controlled/EventControlled.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventControlled = void 0;
+const Event_1 = require("../../../../spec/typedef/instance/Event");
+class EventControlled extends Event_1.Event {
+    constructor(iid, type, description, list) {
+        super(iid, type, description, list);
+        this.observers = new Map();
+    }
+    addObserver(observer) {
+        this.observers.set(observer.toString(), observer);
+    }
+    doOccurred(o) {
+        for (let item of this.observers) {
+            const observer = item[1];
+            observer(o.eid, o.getArguments());
+        }
+    }
+}
+exports.EventControlled = EventControlled;

package/dist/xiot/core/support/codegen/typedef/controlled/PropertyControlled.d.ts

@@ -0,0 +1,18 @@
+import { Property } from "../../../../spec/typedef/instance/Property";
+import { PropertyID } from "../../../../spec/typedef/xid/PropertyID";
+import { PropertyOperation } from "../../../../spec/typedef/operation/PropertyOperation";
+export declare class PropertyControlled extends Property {
+    private observers;
+    protected getter: (() => Promise<any>) | null;
+    protected setter: ((value: any) => Promise<void>) | null;
+    protected did: () => string;
+    protected siid: () => number;
+    constructor(p: Property);
+    addObserver(observer: (pid: PropertyID, value: Object) => void): void;
+    get(): Promise<any>;
+    set(value: any): Promise<void>;
+    get2(operation: PropertyOperation): Promise<PropertyOperation>;
+    set2(operation: PropertyOperation): Promise<PropertyOperation>;
+    doChange(v: any): void;
+    private pid;
+}

package/dist/xiot/core/support/codegen/typedef/controlled/PropertyControlled.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyControlled = void 0;
+const Property_1 = require("../../../../spec/typedef/instance/Property");
+const PropertyID_1 = require("../../../../spec/typedef/xid/PropertyID");
+const DataFormat_1 = require("../../../../spec/typedef/definition/property/data/DataFormat");
+const Status_1 = require("../../../../spec/typedef/status/Status");
+class PropertyControlled extends Property_1.Property {
+    constructor(p) {
+        super(p.iid, p.type, p.description, p.format, p.access, p.constraintValue, p.unit, p.members);
+        this.observers = new Map();
+        this.getter = null;
+        this.setter = null;
+        this.did = () => "empty";
+        this.siid = () => 0;
+    }
+    addObserver(observer) {
+        this.observers.set(observer.toString(), observer);
+    }
+    get() {
+        if (this.getter != null) {
+            return this.getter();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                reject("getter not found");
+            });
+        }
+    }
+    set(value) {
+        if (this.setter != null) {
+            return this.setter(value);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                reject("setter not found");
+            });
+        }
+    }
+    get2(operation) {
+        if (this.access.isReadable) {
+            if (this.getter != null) {
+                this.getter()
+                    .then(value => {
+                    if (this.format == DataFormat_1.DataFormat.COMBINATION) {
+                        this.setValue(this.toMap(value));
+                    }
+                    else {
+                        this.setValue(value);
+                    }
+                    return operation;
+                })
+                    .catch(error => {
+                    operation.status = Status_1.Status.PROPERTY_VALUE_ERROR;
+                    operation.description = 'error: ' + error.message;
+                    return operation;
+                });
+            }
+            else {
+                operation.status = Status_1.Status.INTERNAL_ERROR;
+                operation.description = "property getter is null";
+                return new Promise((resolve, reject) => {
+                    resolve(operation);
+                });
+            }
+        }
+        operation.status = Status_1.Status.PROPERTY_CANNOT_READ;
+        operation.description = "property cannot read";
+        return new Promise((resolve, reject) => {
+            resolve(operation);
+        });
+    }
+    set2(operation) {
+        if (this.access.isWritable) {
+            if (this.setter != null) {
+                const value = (this.format != DataFormat_1.DataFormat.COMBINATION) ? operation.value : this.valueOf(operation.value());
+                this.setter(value)
+                    .then(x => {
+                    super.setValue(operation.value());
+                    this.doChange(value);
+                    return operation;
+                })
+                    .catch(error => {
+                    operation.status = Status_1.Status.PROPERTY_VALUE_ERROR;
+                    operation.description = 'error: ' + error.message;
+                    return operation;
+                });
+            }
+            else {
+                operation.status = Status_1.Status.INTERNAL_ERROR;
+                operation.description = "property setter is null";
+                return new Promise((resolve, reject) => {
+                    resolve(operation);
+                });
+            }
+        }
+        operation.status = Status_1.Status.PROPERTY_CANNOT_WRITE;
+        operation.description = "property cannot write";
+        return new Promise((resolve, reject) => {
+            resolve(operation);
+        });
+    }
+    doChange(v) {
+        const pid = this.pid();
+        if (this.format == DataFormat_1.DataFormat.COMBINATION) {
+            for (let item of this.observers) {
+                const observer = item[1];
+                observer(pid, this.toMap(v));
+            }
+        }
+        else {
+            for (let item of this.observers) {
+                const observer = item[1];
+                observer(pid, v);
+            }
+        }
+    }
+    pid() {
+        return PropertyID_1.PropertyID.create(this.did(), this.siid(), this.iid);
+    }
+}
+exports.PropertyControlled = PropertyControlled;

package/dist/xiot/core/support/codegen/typedef/controlled/ServiceControlled.d.ts

@@ -0,0 +1,8 @@
+import { Service } from "../../../../spec/typedef/instance/Service";
+import { ServiceType } from "../../../../spec/typedef/definition/urn/ServiceType";
+import { PropertyController } from "../controller/PropertyController";
+import { ActionController } from "../controller/ActionController";
+import { EventController } from "../controller/EventController";
+export declare class ServiceControlled extends Service {
+    constructor(iid: number, type: ServiceType, description: Map<string, string>, properties: PropertyController[], actions: ActionController[], events: EventController[]);
+}

package/dist/xiot/core/support/codegen/typedef/controlled/ServiceControlled.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceControlled = void 0;
+const Service_1 = require("../../../../spec/typedef/instance/Service");
+class ServiceControlled extends Service_1.Service {
+    constructor(iid, type, description, properties, actions, events) {
+        super(iid, type, description, properties, actions, events);
+    }
+}
+exports.ServiceControlled = ServiceControlled;

package/dist/xiot/core/support/codegen/typedef/controller/ActionController.d.ts

@@ -0,0 +1,10 @@
+import { ActionType } from "../../../../spec/typedef/definition/urn/ActionType";
+import { Action } from "../../../../spec/typedef/instance/Action";
+import { ActionInvokerWrapper } from "./operator/ActionInvokerWrapper";
+import { Argument } from "../../../../spec/typedef/instance/Argument";
+import { Result } from "../result/Result";
+export declare class ActionController extends Action {
+    invoker: ActionInvokerWrapper;
+    constructor(iid: number, type: ActionType, description: Map<string, string>, argumentsIn: Argument[], argumentsOut: Argument[]);
+    _result: Result;
+}

package/dist/xiot/core/support/codegen/typedef/controller/ActionController.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionController = void 0;
+const Action_1 = require("../../../../spec/typedef/instance/Action");
+const Result_1 = require("../result/Result");
+class ActionController extends Action_1.Action {
+    constructor(iid, type, description, argumentsIn, argumentsOut) {
+        super(iid, type, description, argumentsIn, argumentsOut);
+        /*----------------------------------------------------------------------
+         * for debugger
+         *----------------------------------------------------------------------*/
+        this._result = new Result_1.Result();
+    }
+}
+exports.ActionController = ActionController;

package/dist/xiot/core/support/codegen/typedef/controller/DeviceController.d.ts

@@ -0,0 +1,23 @@
+import { DeviceInstance } from "../../../../spec/typedef/instance/DeviceInstance";
+import { SummaryController } from "./SummaryController";
+import { ServiceController } from "./ServiceController";
+import { Summary } from "../../../../spec/typedef/summary/Summary";
+import { PropertyOperation } from "../../../../spec/typedef/operation/PropertyOperation";
+import { EventOperation } from "../../../../spec/typedef/operation/EventOperation";
+import { ActionOperation } from "../../../../spec/typedef/operation/ActionOperation";
+import { SomewhereController } from "./SomewhereController";
+import { Somewhere } from "../../../../spec/typedef/somewhere/Somewhere";
+import { Urn } from "../../../../spec/typedef/definition/urn/Urn";
+export declare class DeviceController extends DeviceInstance {
+    did: string;
+    summary: SummaryController;
+    somewhere: SomewhereController;
+    constructor(type: Urn, description: Map<string, string>, services: ServiceController[]);
+    getServiceControllers(): ServiceController[];
+    handleSummaryChanged(summary: Summary): boolean;
+    handleSomewhereChanged(somewhere: Somewhere): boolean;
+    handlePropertiesChanged(list: PropertyOperation[]): void;
+    handlePropertyChanged(o: PropertyOperation): void;
+    handleEventOccurred(e: EventOperation): void;
+    setOperator(setter: ((property: PropertyOperation) => Promise<PropertyOperation>), invoker: ((action: ActionOperation) => Promise<ActionOperation>)): void;
+}

package/dist/xiot/core/support/codegen/typedef/controller/DeviceController.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceController = void 0;
+const DeviceInstance_1 = require("../../../../spec/typedef/instance/DeviceInstance");
+const ServiceController_1 = require("./ServiceController");
+const IotError_1 = require("../../../../spec/typedef/error/IotError");
+const Status_1 = require("../../../../spec/typedef/status/Status");
+const PropertySetterWrapper_1 = require("./operator/PropertySetterWrapper");
+const ActionInvokerWrapper_1 = require("./operator/ActionInvokerWrapper");
+const PropertyController_1 = require("./PropertyController");
+const ActionController_1 = require("./ActionController");
+class DeviceController extends DeviceInstance_1.DeviceInstance {
+    constructor(type, description, services) {
+        super(type, description, services);
+        this.did = 'xxx';
+    }
+    getServiceControllers() {
+        const list = [];
+        for (let value of this.services.values()) {
+            if (value instanceof ServiceController_1.ServiceController) {
+                list.push(value);
+            }
+        }
+        return list;
+    }
+    handleSummaryChanged(summary) {
+        return this.summary.update(summary);
+    }
+    handleSomewhereChanged(somewhere) {
+        return this.somewhere.update(somewhere);
+    }
+    handlePropertiesChanged(list) {
+        for (let o of list) {
+            this.handlePropertyChanged(o);
+        }
+    }
+    handlePropertyChanged(o) {
+        const service = this.services.get(o.siid());
+        if (service != null) {
+            if (service instanceof ServiceController_1.ServiceController) {
+                service.handlePropertyChanged(o);
+            }
+            else {
+                throw new IotError_1.IotError(Status_1.Status.INTERNAL_ERROR, "service not ServiceController");
+            }
+        }
+        else {
+            throw new IotError_1.IotError(Status_1.Status.SERVICE_NOT_FOUND, "service not found: " + o.siid());
+        }
+    }
+    handleEventOccurred(e) {
+        const service = this.services.get(e.siid());
+        if (service != null) {
+            if (service instanceof ServiceController_1.ServiceController) {
+                service.handleEventOccurred(e);
+            }
+            else {
+                throw new IotError_1.IotError(Status_1.Status.INTERNAL_ERROR, "service not ServiceController");
+            }
+        }
+        else {
+            throw new IotError_1.IotError(Status_1.Status.SERVICE_NOT_FOUND, "service not found: " + e.siid());
+        }
+    }
+    setOperator(setter, invoker) {
+        for (let item of this.services) {
+            const siid = item[0];
+            const service = item[1];
+            const setterWrapper = new PropertySetterWrapper_1.PropertySetterWrapper(this.did, siid, setter);
+            const invokerWrapper = new ActionInvokerWrapper_1.ActionInvokerWrapper(this.did, siid, invoker);
+            for (let p of service.properties) {
+                const property = p[1];
+                if (property instanceof PropertyController_1.PropertyController) {
+                    property.setter = setterWrapper;
+                }
+            }
+            for (let a of service.actions) {
+                const action = a[1];
+                if (action instanceof ActionController_1.ActionController) {
+                    action.invoker = invokerWrapper;
+                }
+            }
+        }
+    }
+}
+exports.DeviceController = DeviceController;

package/dist/xiot/core/support/codegen/typedef/controller/EventController.d.ts

@@ -0,0 +1,8 @@
+import { Event } from "../../../../spec/typedef/instance/Event";
+import { EventType } from "../../../../spec/typedef/definition/urn/EventType";
+import { Argument } from "../../../../spec/typedef/instance/Argument";
+import { EventOperation } from "../../../../spec/typedef/operation/EventOperation";
+export declare class EventController extends Event {
+    constructor(iid: number, type: EventType, description: Map<string, string>, list: Argument[]);
+    handleEventOccurred(o: EventOperation): void;
+}

package/dist/xiot/core/support/codegen/typedef/controller/EventController.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventController = void 0;
+const Event_1 = require("../../../../spec/typedef/instance/Event");
+class EventController extends Event_1.Event {
+    constructor(iid, type, description, list) {
+        super(iid, type, description, list);
+    }
+    handleEventOccurred(o) {
+    }
+}
+exports.EventController = EventController;

package/dist/xiot/core/support/codegen/typedef/controller/PropertyController.d.ts

@@ -0,0 +1,27 @@
+import { Property } from "../../../../spec/typedef/instance/Property";
+import { PropertyOperation } from "../../../../spec/typedef/operation/PropertyOperation";
+import { PropertySetterWrapper } from "./operator/PropertySetterWrapper";
+import { Result } from "../result/Result";
+import { ValueRange } from "../../../../spec/typedef/definition/property/ValueRange";
+import { ValueList } from "../../../../spec/typedef/definition/property/ValueList";
+export declare class PropertyController extends Property {
+    setter: PropertySetterWrapper;
+    private observers;
+    constructor(p: Property);
+    addObserver(observer: ((value: any) => void)): void;
+    removeObserver(observer: ((value: any) => void)): void;
+    handlePropertyChanged(o: PropertyOperation): void;
+    set(value: any): Promise<any>;
+    _result: Result;
+    getFormatString(): string;
+    isEditableTextValue(): boolean;
+    isReadOnlyTextValue(): boolean;
+    formatBoolean(): boolean;
+    formatNumber(): boolean;
+    formatString(): boolean;
+    hasConstraintValue(): boolean;
+    hasValueRange(): boolean;
+    hasValueList(): boolean;
+    valueRange(): ValueRange | null;
+    valueList(): ValueList | null;
+}

package/dist/xiot/core/support/codegen/typedef/controller/PropertyController.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyController = void 0;
+const Property_1 = require("../../../../spec/typedef/instance/Property");
+const DataFormat_1 = require("../../../../spec/typedef/definition/property/data/DataFormat");
+const Result_1 = require("../result/Result");
+const ValueRange_1 = require("../../../../spec/typedef/definition/property/ValueRange");
+const ValueList_1 = require("../../../../spec/typedef/definition/property/ValueList");
+const PropertyValue_1 = require("../../../../spec/typedef/instance/PropertyValue");
+class PropertyController extends Property_1.Property {
+    constructor(p) {
+        super(p.iid, p.type, p.description, p.format, p.access, p.constraintValue, p.unit, p.members);
+        this.observers = new Map();
+        /*----------------------------------------------------------------------
+         * for debugger
+         *----------------------------------------------------------------------*/
+        this._result = new Result_1.Result();
+        this.value = PropertyValue_1.PropertyValue.copy(p.value);
+    }
+    addObserver(observer) {
+        this.observers.set(observer.toString(), observer);
+    }
+    removeObserver(observer) {
+        this.observers.delete(observer.toString());
+    }
+    handlePropertyChanged(o) {
+        super.setValueForOperation(o);
+        if (o.isCompleted()) {
+            this.observers.forEach((observer, id) => {
+                observer(this.getValue());
+            });
+        }
+        else {
+            console.log(`PropertyOperation: ${o.status} ${o.description}`);
+        }
+    }
+    set(value) {
+        if (this.access.isWritable) {
+            if (this.setter != null) {
+                if (this.format == DataFormat_1.DataFormat.COMBINATION) {
+                    return this.setter.call(this.iid, this.toMap(value))
+                        .then(value);
+                }
+                else {
+                    return this.setter.call(this.iid, value)
+                        .then(value);
+                }
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    reject("property set: not implemented");
+                });
+            }
+        }
+        return new Promise((resolve, reject) => {
+            reject("property cannot write");
+        });
+    }
+    getFormatString() {
+        return (0, DataFormat_1.DataFormatToString)(this.format);
+    }
+    isEditableTextValue() {
+        if (this.valueList() != null) {
+            return false;
+        }
+        if (this.format === DataFormat_1.DataFormat.BOOL) {
+            return false;
+        }
+        return this.access.isWritable;
+    }
+    isReadOnlyTextValue() {
+        if (this.valueList() != null) {
+            return false;
+        }
+        if (this.format === DataFormat_1.DataFormat.BOOL) {
+            return false;
+        }
+        if (this.access.isWritable) {
+            return false;
+        }
+        return this.access.isReadable;
+    }
+    formatBoolean() {
+        return this.format === DataFormat_1.DataFormat.BOOL;
+    }
+    formatNumber() {
+        switch (this.format) {
+            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:
+            case DataFormat_1.DataFormat.FLOAT:
+                return true;
+            default:
+                return false;
+        }
+    }
+    formatString() {
+        switch (this.format) {
+            case DataFormat_1.DataFormat.STRING:
+            case DataFormat_1.DataFormat.TLV8:
+            case DataFormat_1.DataFormat.HEX:
+                return true;
+            default:
+                return false;
+        }
+    }
+    hasConstraintValue() {
+        return this.constraintValue != null;
+    }
+    hasValueRange() {
+        if (this.constraintValue == null) {
+            return false;
+        }
+        return this.constraintValue instanceof ValueRange_1.ValueRange;
+    }
+    hasValueList() {
+        if (this.constraintValue == null) {
+            return false;
+        }
+        return this.constraintValue instanceof ValueList_1.ValueList;
+    }
+    valueRange() {
+        if (this.constraintValue == null) {
+            return null;
+        }
+        if (this.constraintValue instanceof ValueRange_1.ValueRange) {
+            return this.constraintValue;
+        }
+        return null;
+    }
+    valueList() {
+        if (this.constraintValue !== null) {
+            if (this.constraintValue instanceof ValueList_1.ValueList) {
+                return this.constraintValue;
+            }
+        }
+        return null;
+    }
+}
+exports.PropertyController = PropertyController;