node-opcua-address-space 2.51.0

package/src/ua_object_impl.ts

@@ -0,0 +1,203 @@
+/**
+ * @module node-opcua-address-space
+ */
+import * as chalk from "chalk";
+
+import { assert } from "node-opcua-assert";
+import { isValidByte } from "node-opcua-basic-types";
+import { NodeClass, QualifiedNameLike, QualifiedNameOptions } from "node-opcua-data-model";
+import { AttributeIds } from "node-opcua-data-model";
+import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { getCurrentClock } from "node-opcua-date-time";
+import { NodeId } from "node-opcua-nodeid";
+import { NumericRange } from "node-opcua-numeric-range";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+import {
+    EventTypeLike,
+    RaiseEventData,
+    ISessionContext,
+    UAMethod,
+    UAObject,
+    UAObjectType,
+    CloneOptions, CloneFilter, CloneExtraInfo, BaseNode, UAEventType
+} from "node-opcua-address-space-base";
+
+import { BaseNodeImpl } from "./base_node_impl";
+import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private";
+import { apply_condition_refresh } from "./apply_condition_refresh";
+
+export class UAObjectImpl extends BaseNodeImpl implements UAObject {
+    public readonly nodeClass = NodeClass.Object;
+    public readonly eventNotifier: number;
+    public readonly symbolicName: string;
+
+    get typeDefinitionObj(): UAObjectType {
+        return super.typeDefinitionObj as UAObjectType;
+    }
+
+    constructor(options: any) {
+        super(options);
+        this.eventNotifier = options.eventNotifier || 0;
+        assert(typeof this.eventNotifier === "number" && isValidByte(this.eventNotifier));
+        this.symbolicName = options.symbolicName || null;
+    }
+
+    public readAttribute(
+        context: ISessionContext | null,
+        attributeId: AttributeIds,
+        indexRange?: NumericRange,
+        dataEncoding?: QualifiedNameLike | null
+    ): DataValue {
+        indexRange;
+        dataEncoding;
+        const now = getCurrentClock();
+        const options: DataValueLike = {};
+        switch (attributeId) {
+            case AttributeIds.EventNotifier:
+                assert(isValidByte(this.eventNotifier));
+                options.value = { dataType: DataType.Byte, value: this.eventNotifier };
+                options.serverTimestamp = now.timestamp;
+                options.serverPicoseconds = now.picoseconds;
+                options.statusCode = StatusCodes.Good;
+                break;
+            default:
+                return BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId, indexRange, dataEncoding);
+        }
+        return new DataValue(options);
+    }
+
+    public clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAObject {
+        options = options || {};
+        options = {
+            ...options,
+            eventNotifier: this.eventNotifier,
+            symbolicName: this.symbolicName
+        };
+
+        const cloneObject = _clone.call(this, UAObjectImpl, options, optionalFilter, extraInfo) as UAObject;
+        // xx  newObject.propagate_back_references();
+        // xx newObject.install_extra_properties();
+        return cloneObject;
+    }
+
+    /**
+     * returns true if the object has some opcua methods
+     */
+    public get hasMethods(): boolean {
+        return this.getMethods().length > 0;
+    }
+
+    public getMethodByName(methodName: QualifiedNameOptions): UAMethod | null;
+    public getMethodByName(methodName: string, namespaceIndex?: number): UAMethod | null;
+    public getMethodByName(methodName: QualifiedNameLike, namespaceIndex?: number): UAMethod | null {
+        return super.getMethodByName(methodName as any, namespaceIndex);
+    }
+
+    public getMethods(): UAMethod[] {
+        return super.getMethods();
+    }
+
+    /**
+     * Raise a transient Event
+     */
+    public raiseEvent(eventType: EventTypeLike | BaseNode, data: RaiseEventData): void {
+        const addressSpace = this.addressSpace;
+
+        if (typeof eventType === "string") {
+            const eventTypeFound = addressSpace.findEventType(eventType);
+            if (!eventTypeFound) {
+                throw new Error("raiseEvent: eventType cannot find event Type " + eventType.toString());
+            }
+            eventType = eventTypeFound;
+            if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
+                throw new Error("eventType must exist and be an UAObjectType");
+            }
+        } else if (eventType instanceof NodeId) {
+            const eventTypeFound = addressSpace.findNode(eventType) as BaseNode;
+            if (!eventTypeFound) {
+                throw new Error("raiseEvent: eventType cannot find event Type " + eventType.toString());
+            }
+            eventType = eventTypeFound!;
+            if (!eventType || eventType.nodeClass !== NodeClass.ObjectType) {
+                throw new Error("eventType must exist and be an UAObjectType" + eventType.toString());
+            }
+        }
+
+        eventType = eventType as UAEventType;
+
+        let eventTypeNode: UAEventType = eventType as UAEventType;
+        // istanbul ignore next
+        if (!eventTypeNode) {
+            throw new Error("UAObject#raiseEventType : Cannot find event type :" + eventType.toString());
+        }
+
+        // coerce EventType
+        eventTypeNode = addressSpace.findEventType(eventType as UAEventType) as UAEventType;
+        const baseEventType = addressSpace.findEventType("BaseEventType")!;
+        assert(eventTypeNode.isSupertypeOf(baseEventType));
+
+        data.$eventDataSource = eventTypeNode;
+        data.sourceNode = data.sourceNode || { dataType: DataType.NodeId, value: this.nodeId };
+
+        const eventData1 = addressSpace.constructEventData(eventTypeNode, data);
+
+        this._bubble_up_event(eventData1);
+    }
+
+    public _bubble_up_event(eventData: any) {
+        const addressSpace = this.addressSpace;
+
+        const queue: any[] = [];
+        // walk up the hasNotify / hasEventSource chain
+        const m: any = {};
+
+        // all events are notified to the server object
+        // emit on server object
+        const server = addressSpace.findNode("Server") as UAObject;
+
+        if (server) {
+            assert(server.eventNotifier > 0x00, "Server must be an event notifier");
+            server.emit("event", eventData);
+            m[server.nodeId.toString()] = server;
+        } else {
+            // tslint:disable:no-console
+            console.warn(
+                chalk.yellow("Warning. ") +
+                    chalk.cyan("UAObject#raiseEvent") +
+                    chalk.red(" cannot find Server object on addressSpace")
+            );
+        }
+
+        addInQueue(this);
+
+        function addInQueue(obj: BaseNode) {
+            const key: string = obj.nodeId.toString();
+            if (!m[key]) {
+                m[key] = obj;
+                queue.push(obj);
+            }
+        }
+
+        while (queue.length) {
+            const obj = queue.pop();
+            // emit on object
+            obj.emit("event", eventData);
+
+            const elements1 = obj.findReferencesAsObject("HasNotifier", false);
+            elements1.forEach(addInQueue);
+
+            const elements2 = obj.findReferencesAsObject("HasEventSource", false);
+            elements2.forEach(addInQueue);
+        }
+    }
+    public _conditionRefresh(_cache?: any) {
+        apply_condition_refresh.call(this, _cache);
+    }
+
+    public toString(): string {
+        const options = new ToStringBuilder();
+        UAObject_toString.call(this, options);
+        return options.toString();
+    }
+}

package/src/ua_object_type_impl.ts

@@ -0,0 +1,158 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { AttributeIds } from "node-opcua-data-model";
+import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import * as utils from "node-opcua-utils";
+import { DataType } from "node-opcua-variant";
+import {
+    AddObjectOptions,
+    InstantiateObjectOptions,
+    ISessionContext,
+    UAObject,
+    UAObjectType,
+    UAReference
+} from "node-opcua-address-space-base";
+
+import { SessionContext } from "../source/session_context";
+import { BaseNodeImpl } from "./base_node_impl";
+import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
+import * as tools from "./tool_isSupertypeOf";
+import { assertUnusedChildBrowseName, initialize_properties_and_components, topMostParentIsObjectTypeOrVariableType } from "./ua_variable_type_impl";
+import { AddressSpacePrivate } from "./address_space_private";
+
+export class UAObjectTypeImpl extends BaseNodeImpl implements UAObjectType {
+    public readonly nodeClass = NodeClass.ObjectType;
+    public readonly isAbstract: boolean;
+    /**
+     * returns true if the object has some opcua methods
+     */
+    public get hasMethods(): boolean {
+        return this.getMethods().length > 0;
+    }
+    public get subtypeOf(): NodeId | null {
+        return get_subtypeOf.call(this);
+    }
+    public get subtypeOfObj(): UAObjectType | null {
+        return get_subtypeOfObj.call(this) as any as UAObjectType;
+    }
+    public isSupertypeOf = tools.construct_isSupertypeOf<UAObjectType>(UAObjectTypeImpl);
+
+    constructor(options: any) {
+        super(options);
+        this.isAbstract = utils.isNullOrUndefined(options.isAbstract) ? false : options.isAbstract;
+    }
+
+    public readAttribute(context: ISessionContext, attributeId: AttributeIds): DataValue {
+        assert(context instanceof SessionContext);
+        const options: DataValueLike = {};
+        switch (attributeId) {
+            case AttributeIds.IsAbstract:
+                options.value = {
+                    dataType: DataType.Boolean,
+                    value: !!this.isAbstract
+                };
+                options.statusCode = StatusCodes.Good;
+                break;
+            default:
+                return BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
+        }
+        return new DataValue(options);
+    }
+
+    /**
+     * instantiate an object of this UAObjectType
+     * The instantiation takes care of object type inheritance when constructing inner properties and components.
+     * @method instantiate
+     * @param options
+     * @param options.browseName
+     * @param [options.description]
+     * @param [options.organizedBy] the parent Folder holding this object
+     * @param [options.componentOf] the parent Object holding this object
+     * @param [options.notifierOf]
+     * @param [options.eventSourceOf]
+     * @param [options.optionals = [] name of the optional child to create
+     * @param [options.modellingRule]
+     * @param [options.encodingOf]
+     *
+     *
+     * Note : HasComponent usage scope
+     *
+     *    Source          |     Destination
+     * -------------------+---------------------------
+     *  Object            | Object, Variable,Method
+     *  ObjectType        |
+     * -------------------+---------------------------
+     *  DataVariable      | Variable
+     *  DataVariableType  |
+     */
+    public instantiate(options: InstantiateObjectOptions): UAObject {
+        const addressSpace = this.addressSpace as AddressSpacePrivate;
+        assert(!this.isAbstract, "cannot instantiate abstract UAObjectType");
+
+        assert(options, "missing option object");
+        assert(
+            typeof options.browseName === "string" || (options.browseName !== null && typeof options.browseName === "object"),
+            "expecting a browse name"
+        );
+
+        assert(!Object.prototype.hasOwnProperty.call(options,"propertyOf"), "an Object shall not be a PropertyOf an other object");
+        assert(!Object.prototype.hasOwnProperty.call(options,"optional"), "do you mean optionals ?");
+
+        assertUnusedChildBrowseName(addressSpace, options);
+
+        const baseObjectType = addressSpace.findObjectType("BaseObjectType")!;
+        assert(baseObjectType, "BaseObjectType must be defined in the address space");
+
+        const references: UAReference[] = [];
+
+        const copyAlsoModellingRules = topMostParentIsObjectTypeOrVariableType(addressSpace, options);
+
+                
+        const opts: AddObjectOptions = {
+            browseName: options.browseName,
+            componentOf: options.componentOf,
+            description: options.description || this.description,
+            encodingOf: options.encodingOf,
+            eventSourceOf: options.eventSourceOf,
+            notifierOf: options.notifierOf,
+            organizedBy: options.organizedBy,
+            references,
+
+            typeDefinition: this.nodeId,
+
+            nodeId: options.nodeId,
+
+            eventNotifier: options.eventNotifier === undefined ? 0 : options.eventNotifier,
+
+            modellingRule: options.modellingRule
+        };
+
+        const namespace = options.namespace || this.addressSpace.getOwnNamespace();
+
+        const instance = namespace.addObject(opts);
+
+        initialize_properties_and_components(instance, baseObjectType, this, copyAlsoModellingRules, options.optionals);
+
+        assert(instance.typeDefinition.toString() === this.nodeId.toString());
+
+        instance.install_extra_properties();
+
+        if (this._postInstantiateFunc) {
+            this._postInstantiateFunc(instance, this, options);
+        }
+
+        return instance;
+    }
+
+    public toString(): string {
+        const options = new ToStringBuilder();
+        UAObjectType_toString.call(this, options);
+        return options.toString();
+    }
+}

package/src/ua_reference_type_impl.ts

@@ -0,0 +1,174 @@
+/**
+ * @module node-opcua-address-space
+ */
+
+import { UAReference, UAReferenceType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { coerceLocalizedText, LocalizedTextOptions } from "node-opcua-data-model";
+import { LocalizedText, NodeClass } from "node-opcua-data-model";
+import { AttributeIds } from "node-opcua-data-model";
+import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+
+import { SessionContext, UAReferenceType as UAReferenceTypePublic } from "../source";
+import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+import * as tools from "./tool_isSupertypeOf";
+import { get_subtypeOf, get_subtypeOfObj } from "./tool_isSupertypeOf";
+import { ReferenceImpl } from "./reference_impl";
+import {
+    BaseNode_getCache
+} from "./base_node_private";
+
+
+const ReferenceTypeCounter = { count: 0 };
+
+
+function _internal_getAllSubtypes(referenceType: UAReferenceType): UAReferenceTypePublic[] {
+    const addressSpace = referenceType.addressSpace;
+    const possibleReferenceTypes: UAReferenceType[] = [];
+
+    const hasSubtypeReferenceType = addressSpace.findReferenceType("HasSubtype")!;
+
+    function _findAllSubType(referenceTypeInner: UAReferenceType) {
+        possibleReferenceTypes.push(referenceTypeInner);
+        assert(referenceTypeInner.nodeClass === NodeClass.ReferenceType);
+        const references = referenceTypeInner.findReferences(hasSubtypeReferenceType, true);
+        for (const _r of references) {
+            const subType: UAReferenceTypePublic = addressSpace.findReferenceType(_r.nodeId)!;
+            _findAllSubType(subType);
+        }
+    }
+    _findAllSubType(referenceType);
+    return possibleReferenceTypes;
+}
+
+function _getAllSubtypes(ref: UAReferenceType) {
+
+    const _cache = BaseNode_getCache(ref);
+
+    if (!_cache._allSubTypesVersion || _cache._allSubTypesVersion < ReferenceTypeCounter.count) {
+        _cache._allSubTypes = null;
+    }
+    if (!_cache._allSubTypes) {
+        _cache._allSubTypes = _internal_getAllSubtypes(ref);
+        _cache._allSubTypesVersion = ReferenceTypeCounter.count;
+    }
+    return _cache._allSubTypes;
+}
+
+function _internal_getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
+    const possibleReferenceTypes = _getAllSubtypes(referenceType);
+    // create a index of reference type with browseName as key for faster search
+    const keys: any = {};
+    for (const refType of possibleReferenceTypes) {
+        keys[refType.nodeId.toString()] = refType;
+    }
+    return keys;
+}
+
+function _getSubtypeIndex(referenceType: UAReferenceType): { [key: string]: UAReferenceTypePublic } {
+
+    const _cache = BaseNode_getCache(referenceType);
+    if (!_cache._subtype_idx  || _cache._subtype_idxVersion < ReferenceTypeCounter.count) {
+        // the cache need to be invalidated
+        _cache._subtype_idx = null;
+    }
+    if (!_cache._subtype_idx) {
+        _cache._subtype_idx = _internal_getSubtypeIndex(referenceType);
+        _cache._subtype_idxVersion = ReferenceTypeCounter.count;
+    }
+    return _cache._subtype_idx;
+}
+
+
+export interface UAReferenceTypeOptions extends InternalBaseNodeOptions {
+    isAbstract?: boolean;
+    symmetric?: boolean;
+    inverseName: null | string | LocalizedTextOptions;
+}
+export class UAReferenceTypeImpl extends BaseNodeImpl implements UAReferenceType {
+    public readonly nodeClass = NodeClass.ReferenceType;
+    public readonly isAbstract: boolean;
+    public readonly symmetric: boolean;
+    public readonly inverseName: LocalizedText;
+
+    public get subtypeOfObj(): UAReferenceTypePublic | null {
+        return get_subtypeOfObj.call(this) as UAReferenceType;
+    }
+
+    public get subtypeOf(): NodeId | null {
+        return get_subtypeOf.call(this);
+    }
+
+    /**
+     * returns true if self is  a super type of baseType
+     */
+    public isSupertypeOf = tools.construct_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+
+    /**
+     * @private
+     */
+    public _slow_isSupertypeOf = tools.construct_slow_isSupertypeOf<UAReferenceType>(UAReferenceTypeImpl);
+
+    constructor(options: UAReferenceTypeOptions) {
+        super(options);
+        this.isAbstract = options.isAbstract === undefined ? false : !!options.isAbstract;
+        this.symmetric = options.symmetric === undefined ? false : !!options.symmetric;
+        // Note: Inverse name is not required anymore in 1.0.4
+        this.inverseName = coerceLocalizedText(options.inverseName || this.browseName.name)!;
+
+        ReferenceTypeCounter.count += 1;
+    }
+
+    public readAttribute(context: SessionContext | null, attributeId: AttributeIds): DataValue {
+        assert(!context || context instanceof SessionContext);
+
+        const options: DataValueLike = {};
+        switch (attributeId) {
+            case AttributeIds.IsAbstract:
+                options.value = { dataType: DataType.Boolean, value: !!this.isAbstract };
+                options.statusCode = StatusCodes.Good;
+                break;
+            case AttributeIds.Symmetric:
+                options.value = { dataType: DataType.Boolean, value: !!this.symmetric };
+                options.statusCode = StatusCodes.Good;
+                break;
+            case AttributeIds.InverseName: // LocalizedText
+                options.value = { dataType: DataType.LocalizedText, value: this.inverseName };
+                options.statusCode = StatusCodes.Good;
+                break;
+            default:
+                return super.readAttribute(context, attributeId);
+        }
+        return new DataValue(options);
+    }
+
+    public toString(): string {
+        let str = "";
+        str += this.isAbstract ? "A" : " ";
+        str += this.symmetric ? "S" : " ";
+        str += " " + this.browseName.toString() + "/" + this.inverseName.text + " ";
+        str += this.nodeId.toString();
+        return str;
+    }
+
+    public install_extra_properties(): void { /**  */ }
+
+    /**
+     * returns a array of all ReferenceTypes in the addressSpace that are self or a subType of self
+     * recursively
+     */
+    public getAllSubtypes(): UAReferenceType[] {
+        return _getAllSubtypes(this);
+    }
+
+    public checkHasSubtype(ref: UAReference | NodeId): boolean {
+        const _index = _getSubtypeIndex(this);
+        const referenceTypeNodeId = ref instanceof ReferenceImpl ? ref.nodeId : ref as NodeId;
+        const _key = referenceTypeNodeId.toString();
+        return !!_index[_key];
+    }
+
+}