node-opcua-address-space 2.98.2 → 2.100.0

package/src/ua_variable_type_impl.ts

@@ -19,14 +19,17 @@ import {
     UAReference,
     UAVariable,
     UAVariableType,
-    CloneFilter
+    CloneFilter,
+    CloneHelper,
+    reconstructFunctionalGroupType,
+    reconstructNonHierarchicalReferences
 } from "node-opcua-address-space-base";
-import { ReferenceTypeIds } from "node-opcua-constants";
+
 import { coerceQualifiedName, NodeClass, QualifiedName, BrowseDirection, AttributeIds } from "node-opcua-data-model";
 import { DataValue, DataValueLike } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
-import { coerceNodeId, makeNodeId, NodeId, NodeIdLike, sameNodeId } from "node-opcua-nodeid";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { coerceNodeId, NodeId, NodeIdLike, sameNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
 import { UInt32 } from "node-opcua-basic-types";
 import { isNullOrUndefined } from "node-opcua-utils";
 import { DataType, Variant, VariantArrayType, verifyRankAndDimensions } from "node-opcua-variant";
@@ -402,103 +405,6 @@ class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
     }
 }
 
-/*
- * @function _get_parent_as_VariableOrObjectType
- * @param originalObject
- * @return {null|BaseNode}
- * @private
- */
-function _get_parent_as_VariableOrObjectType(originalObject: BaseNode): UAVariableType | UAObjectType | null {
-    if (originalObject.nodeClass === NodeClass.Method) {
-        return null;
-    }
-
-    const addressSpace = originalObject.addressSpace;
-
-    const parents = originalObject.findReferencesEx("HasChild", BrowseDirection.Inverse);
-
-    // istanbul ignore next
-    if (parents.length > 1) {
-        warningLog(" object ", originalObject.browseName.toString(), " has more than one parent !");
-        warningLog(originalObject.toString());
-        warningLog(" parents : ");
-        for (const parent of parents) {
-            warningLog("     ", parent.toString(), addressSpace.findNode(parent.nodeId)!.browseName.toString());
-        }
-        return null;
-    }
-
-    assert(parents.length === 0 || parents.length === 1);
-    if (parents.length === 0) {
-        return null;
-    }
-    const theParent = addressSpace.findNode(parents[0]!.nodeId)!;
-    if (theParent && (theParent.nodeClass === NodeClass.VariableType || theParent.nodeClass === NodeClass.ObjectType)) {
-        return theParent as UAVariableType | UAObjectType;
-    }
-    return null;
-}
-
-interface CloneInfo {
-    cloned: UAObject | UAVariable | UAMethod;
-    original: UAVariableType | UAObjectType;
-}
-class CloneHelper {
-    public level = 0;
-    private readonly mapOrgToClone: Map<string, CloneInfo> = new Map();
-
-    public pad(): string {
-        return " ".padEnd(this.level * 2, " ");
-    }
-    public registerClonedObject<TT extends UAVariableType | UAObjectType, T extends UAObject | UAVariable | UAMethod>(
-        objInType: TT,
-        clonedObj: T
-    ) {
-        this.mapOrgToClone.set(objInType.nodeId.toString(), {
-            cloned: clonedObj,
-            original: objInType
-        });
-
-        //
-        //   /-----------------------------\
-        //   | AcknowledgeableConditionType |
-        //   \-----------------------------/
-        //              ^        |
-        //              |        +---------------------|- (EnabledState)   (shadow element)
-        //              |
-        //   /-----------------------------\
-        //   |        AlarmConditionType   |
-        //   \-----------------------------/
-        //              |
-        //              +-------------------------------|- EnabledState    <
-        //
-        // find also child object with the same browse name that are
-        // overridden in the SuperType
-        //
-        const origParent = _get_parent_as_VariableOrObjectType(objInType);
-        if (origParent) {
-            let base = origParent.subtypeOfObj;
-            while (base) {
-                const shadowChild = base.getChildByName(objInType.browseName) as UAObjectType | UAVariableType | null;
-                if (shadowChild) {
-                    this.mapOrgToClone.set(shadowChild.nodeId.toString(), {
-                        cloned: clonedObj,
-                        original: shadowChild
-                    });
-                }
-                base = base.subtypeOfObj;
-            }
-        }
-        // find subTypeOf
-    }
-    public getCloned(original: UAVariableType | UAObjectType): UAObject | UAVariable | UAMethod | null {
-        const info = this.mapOrgToClone.get(original.nodeId.toString());
-        if (info) {
-            return info.cloned;
-        }
-        return null;
-    }
-}
 // install properties and components on a instantiated Object
 //
 // based on their ModelingRule
@@ -514,7 +420,7 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
     typeDefinitionNode: T,
     copyAlsoModellingRules: boolean,
     optionalsMap: OptionalMap,
-    extraInfo: CloneHelper, 
+    extraInfo: CloneHelper,
     browseNameMap: Set<string>
 ) {
     if (doDebug) {
@@ -539,7 +445,6 @@ function _initialize_properties_and_components<B extends UAObject | UAVariable |
             typeDefinitionNode.browseName.toString()
         );
 
-  
     _clone_hierarchical_references(typeDefinitionNode, instance, copyAlsoModellingRules, filter, extraInfo, browseNameMap);
 
     // now apply recursion on baseTypeDefinition  to get properties and components from base class
@@ -633,192 +538,27 @@ export function assertUnusedChildBrowseName(addressSpace: AddressSpacePrivate, o
 exports.assertUnusedChildBrowseName = assertUnusedChildBrowseName;
 exports.initialize_properties_and_components = initialize_properties_and_components;
 
-const hasTypeDefinitionNodeId = makeNodeId(ReferenceTypeIds.HasTypeDefinition);
-const hasModellingRuleNodeId = makeNodeId(ReferenceTypeIds.HasModellingRule);
-
-/**
- * remove unwanted reference such as HasTypeDefinition and HasModellingRule
- * from the list
- */
-function _remove_unwanted_ref(references: UAReference[]): UAReference[] {
-    // filter out HasTypeDefinition (i=40) , HasModellingRule (i=37);
-    references = references.filter(
-        (reference: UAReference) =>
-            !sameNodeId(reference.referenceType, hasTypeDefinitionNodeId) &&
-            !sameNodeId(reference.referenceType, hasModellingRuleNodeId)
-    );
-    return references;
-}
-
-/**
- *
- */
-function findNonHierarchicalReferences(originalObject: BaseNode): UAReference[] {
-    // todo: MEMOIZE this method
-    const addressSpace: IAddressSpace = originalObject.addressSpace;
-    const referenceId = addressSpace.findReferenceType("NonHierarchicalReferences");
-    if (!referenceId) {
-        return [];
-    }
-    assert(referenceId);
-
-    // we need to explore the non hierarchical references backwards
-    let references = originalObject.findReferencesEx("NonHierarchicalReferences", BrowseDirection.Inverse);
-
-    references = ([] as UAReference[]).concat(
-        references,
-        originalObject.findReferencesEx("HasEventSource", BrowseDirection.Inverse)
-    );
-
-    const parent = _get_parent_as_VariableOrObjectType(originalObject);
-
-    if (parent && parent.subtypeOfObj) {
-        // parent is a ObjectType or VariableType and is not a root type
-        assert(parent.nodeClass === NodeClass.VariableType || parent.nodeClass === NodeClass.ObjectType);
-
-        // let investigate the same child base child
-        const child = parent.subtypeOfObj!.getChildByName(originalObject.browseName);
-
-        if (child) {
-            const baseRef = findNonHierarchicalReferences(child);
-            references = ([] as UAReference[]).concat(references, baseRef);
-        }
-    }
-    // perform some cleanup
-    references = _remove_unwanted_ref(references);
-
-    return references;
-}
-
-function reconstructNonHierarchicalReferences(extraInfo: any): void {
-    const findImplementedObject = (ref: UAReference): CloneInfo | null =>
-        extraInfo.mapOrgToClone.get(ref.nodeId.toString()) || null;
-
-    // navigate through original objects to find those that are being references by node that
-    // have been cloned .
-    // this could be node organized by some FunctionalGroup
-    //
-    for (const { original, cloned } of extraInfo.mapOrgToClone.values()) {
-        // find NonHierarchical References on original object
-        const originalNonHierarchical = findNonHierarchicalReferences(original);
-
-        if (originalNonHierarchical.length === 0) {
-            continue;
-        }
-
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog(
-                " investigation ",
-                original.browseName.toString(),
-                cloned.nodeClass.toString(),
-                original.nodeClass.toString(),
-                original.nodeId.toString(),
-                cloned.nodeId.toString()
-            );
-        }
-
-        for (const ref of originalNonHierarchical) {
-            const info = findImplementedObject(ref);
-
-            // if the object pointed by this reference is also cloned ...
-            if (info) {
-                const originalDest = info.original;
-                const cloneDest = info.cloned;
-
-                // istanbul ignore next
-                if (doDebug) {
-                    debugLog(
-                        chalk.cyan("   adding reference "),
-                        ref.referenceType,
-                        " from cloned ",
-                        cloned.nodeId.toString(),
-                        cloned.browseName.toString(),
-                        " to cloned ",
-                        cloneDest.nodeId.toString(),
-                        cloneDest.browseName.toString()
-                    );
-                }
-
-                // restore reference
-                cloned.addReference({
-                    isForward: false,
-                    nodeId: cloneDest.nodeId,
-                    referenceType: ref.referenceType
-                });
-            }
-        }
-    }
-}
-
-/**
- * recreate functional group types according to type definition
- *
- * @method reconstructFunctionalGroupType
- * @param baseType
- */
-
-/* @example:
- *
- *    MyDeviceType
- *        |
- *        +----------|- ParameterSet(BaseObjectType)
- *        |                   |
- *        |                   +-----------------|- Parameter1
- *        |                                             ^
- *        +----------|- Config(FunctionalGroupType)     |
- *                                |                     |
- *                                +-------- Organizes---+
- */
-function reconstructFunctionalGroupType(extraInfo: any) {
-    // navigate through original objects to find those that are being organized by some FunctionalGroup
-    for (const { original, cloned } of extraInfo.mapOrgToClone.values()) {
-        const organizedByArray = original.findReferencesEx("Organizes", BrowseDirection.Inverse);
-
-        for (const ref of organizedByArray) {
-            const info = extraInfo.mapOrgToClone.get(ref.nodeId.toString());
-            if (!info) continue;
-
-            const folder = info.original;
-            if (folder.nodeClass !== NodeClass.Object) continue;
-
-            if (!folder.typeDefinitionObj) continue;
-
-            assert(folder.typeDefinitionObj.browseName.name.toString() === "FunctionalGroupType");
-
-            // now create the same reference with the instantiated function group
-            const destFolder = info.cloned as BaseNode;
-
-            assert(ref.referenceType);
-
-            // may be we should check that the referenceType is a subtype of Organizes
-            const alreadyExist = destFolder.findReferences(ref.referenceType,  !ref.isForward).find((r) => r.nodeId === cloned.nodeId);
-            if (alreadyExist) {
-                continue;
-            }
-
-            destFolder.addReference({
-                isForward: !ref.isForward,
-                nodeId: cloned.nodeId,
-                referenceType: ref.referenceType
-            });
-        }
-    }
-}
-
 export function initialize_properties_and_components<
     B extends UAObject | UAVariable | UAMethod,
     T extends UAVariableType | UAObjectType
 >(instance: B, topMostType: T, nodeType: T, copyAlsoModellingRules: boolean, optionals?: string[]): void {
     const extraInfo = new CloneHelper();
 
-    extraInfo.registerClonedObject(nodeType, instance);
+    extraInfo.registerClonedObject(instance, nodeType);
 
     const optionalsMap = makeOptionalsMap(optionals);
 
     const browseNameMap = new Set<string>();
 
-    _initialize_properties_and_components(instance, topMostType, nodeType, copyAlsoModellingRules, optionalsMap, extraInfo, browseNameMap);
+    _initialize_properties_and_components(
+        instance,
+        topMostType,
+        nodeType,
+        copyAlsoModellingRules,
+        optionalsMap,
+        extraInfo,
+        browseNameMap
+    );
 
     reconstructFunctionalGroupType(extraInfo);