node-opcua-address-space 2.179.0 → 2.181.0

package/src/ua_object_type_impl.ts

@@ -1,179 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-
-import type {
-    AddObjectOptions,
-    BaseNodeEvents,
-    InstantiateObjectOptions,
-    ISessionContext,
-    UAObject,
-    UAObjectType,
-    UAReference
-} from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { AttributeIds, type LocalizedTextLike, NodeClass } from "node-opcua-data-model";
-import { DataValue, type DataValueLike } from "node-opcua-data-value";
-import type { NodeId } from "node-opcua-nodeid";
-import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
-
-import { SessionContext } from "../source/session_context";
-import { initialize_properties_and_components } from "./_instantiate_helpers";
-import type { AddressSpacePrivate } from "./address_space_private";
-import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
-import { ToStringBuilder, UAObjectType_toString } from "./base_node_private";
-import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
-import { assertUnusedChildBrowseName, topMostParentIsObjectTypeOrVariableType } from "./ua_variable_type_impl";
-
-export interface UAObjectTypeOptions extends InternalBaseNodeOptions {
-    isAbstract?: boolean | null;
-}
-
-export class UAObjectTypeImpl extends BaseNodeImpl<BaseNodeEvents> 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 unknown as UAObjectType;
-    }
-
-    public isSubtypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
-    /** @deprecated - use  isSubtypeOf instead */
-    public isSupertypeOf = construct_isSubtypeOf<UAObjectType>(UAObjectTypeImpl);
-
-    constructor(options: UAObjectTypeOptions) {
-        super(options);
-        this.isAbstract = options.isAbstract ?? false;
-    }
-
-    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.
-
-     * @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.addInOf]
-     * @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.hasOwn(options, "propertyOf"), "an Object shall not be a PropertyOf an other object");
-        assert(!Object.hasOwn(options, "optional"), "do you mean optionals ?");
-
-        assertUnusedChildBrowseName(addressSpace, options);
-
-        const baseObjectType = addressSpace.findObjectType("BaseObjectType") as UAObjectType;
-        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,
-            displayName: options.displayName || "",
-            description:
-                options.description === undefined
-                    ? (this.description?.clone() as LocalizedTextLike | undefined)
-                    : options.description,
-            encodingOf: options.encodingOf,
-            eventSourceOf: options.eventSourceOf,
-            notifierOf: options.notifierOf,
-            organizedBy: options.organizedBy,
-            addInOf: options.addInOf,
-            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);
-
-        const copyAlsoAllOptionals = options.copyAlsoAllOptionals || false;
-        initialize_properties_and_components(
-            instance,
-            baseObjectType,
-            this,
-            copyAlsoModellingRules,
-            copyAlsoAllOptionals,
-            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

@@ -1,170 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-
-import type { BaseNodeEvents, UAReference, UAReferenceType } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { AttributeIds, LocalizedText, type LocalizedTextOptions, NodeClass } from "node-opcua-data-model";
-import { DataValue, type DataValueLike } from "node-opcua-data-value";
-import type { NodeId } from "node-opcua-nodeid";
-import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
-
-import { SessionContext, type UAReferenceType as UAReferenceTypePublic } from "../source";
-import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
-import { BaseNode_getCache } from "./base_node_private";
-import { ReferenceImpl } from "./reference_impl";
-import { construct_isSubtypeOf, construct_slow_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
-
-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) {
-        if (!hasSubtypeReferenceType) throw new Error("cannot find HasSubtype reference type");
-        possibleReferenceTypes.push(referenceTypeInner);
-        assert(referenceTypeInner.nodeClass === NodeClass.ReferenceType);
-        const references = referenceTypeInner.findReferences(hasSubtypeReferenceType, true);
-        for (const _r of references) {
-            const subType: UAReferenceTypePublic | null = addressSpace.findReferenceType(_r.nodeId);
-            if (!subType) throw new Error("cannot find subtype reference type");
-            _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): Map<string, UAReferenceTypePublic> {
-    const possibleReferenceTypes = _getAllSubtypes(referenceType);
-    // create a index of reference type with browseName as key for faster search
-    const keys: Map<string, UAReferenceType> = new Map();
-    for (const refType of possibleReferenceTypes) {
-        keys.set(refType.nodeId.toString(), refType);
-    }
-    return keys;
-}
-
-function _getSubtypeIndex(referenceType: UAReferenceType): Map<string, UAReferenceTypePublic> {
-    const _cache = BaseNode_getCache(referenceType);
-    if (!_cache._subtype_idx || (_cache._subtype_idxVersion && _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<BaseNodeEvents> 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 unknown as UAReferenceType;
-    }
-
-    public get subtypeOf(): NodeId | null {
-        return get_subtypeOf.call(this);
-    }
-
-    /**
-     * returns true if self is  a super type of baseType
-     */
-    public isSubtypeOf = construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
-
-    /** @deprecated - use `isSubtypeOf` instead*/
-    public isSupertypeOf = construct_isSubtypeOf<UAReferenceType>(UAReferenceTypeImpl);
-
-    /**
-     * @private
-     */
-    public _slow_isSubtypeOf = construct_slow_isSubtypeOf<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 = new LocalizedText(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.has(_key);
-    }
-}