node-opcua-address-space 2.186.17 → 2.187.1

package/impl/nodeset_tools/construct_namespace_dependency.ts

@@ -3,7 +3,8 @@ import assert from "node-opcua-assert";
 import { DataType } from "node-opcua-basic-types";
 import { NodeClass } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import type { ExtensionObject } from "node-opcua-extension-object";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { NodeId } from "node-opcua-nodeid";
 import type { StructureField } from "node-opcua-types";
 import { Variant } from "node-opcua-variant";
 import type { TranslationTable } from "../../api/xml_writer.js";
@@ -11,6 +12,7 @@ import type { BaseNodeImpl } from "../base_node_impl.js";
 import type { NamespacePrivate } from "../namespace_private.js";
 import { ReferenceImpl } from "../reference_impl.js";
 import type { UAVariableImpl } from "../ua_variable_impl.js";
+import type { UAVariableTypeImpl } from "../ua_variable_type_impl.js";
 
 const warningLog = make_warningLog("construct_namespace_dependency");
 const _debugLog = make_debugLog("construct_namespace_dependency");
@@ -212,11 +214,31 @@ export function _getCompleteRequiredModelsFromValuesAndReferences(
         }
     };
 
+    // the exporter translates every NodeId a value holds (an Argument's DataType, a NodeId field of
+    // a structure, a NodeId variable), so each of their namespaces is a dependency whatever its priority
+    const exploreValue = (value: unknown): void => {
+        if (value === null || value === undefined) return;
+        if (value instanceof NodeId) {
+            consider(value.namespace);
+        } else if (value instanceof Variant) {
+            exploreValue(value.value);
+        } else if (Array.isArray(value)) {
+            for (const element of value) exploreValue(element);
+        } else if (value instanceof ExtensionObject) {
+            for (const fieldValue of Object.values(value)) exploreValue(fieldValue);
+        }
+    };
+
     const addressSpace = namespace.addressSpace;
     const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences");
 
     //const maxIndex = Math.max(...requiredNamespaceIndexes);
     for (const node of namespace_.nodeIterator()) {
+        if (node.nodeClass === NodeClass.Variable) {
+            exploreValue((node as UAVariableImpl).$dataValue?.value);
+        } else if (node.nodeClass === NodeClass.VariableType) {
+            exploreValue((node as UAVariableTypeImpl).value);
+        }
         const references = (<BaseNodeImpl>node).allReferences();
         for (const reference of references) {
             // check referenceId

package/impl/reference_impl.ts

@@ -157,7 +157,8 @@ export class ReferenceImpl implements UAReference {
 
     // cache
     private __hash?: string;
-    private __key?: ReferenceKey;
+    /** the key this reference is indexed under, computed once by key(); read by ReferenceIndex */
+    public _key?: ReferenceKey;
 
     constructor(options: AddReferenceOpts | UAReference) {
         assert(options.referenceType instanceof NodeId);
@@ -209,10 +210,10 @@ export class ReferenceImpl implements UAReference {
      * the key this reference is indexed under in the node holding it, computed once
      */
     key(ordinals: ReferenceTypeOrdinals): ReferenceKey {
-        if (this.__key === undefined) {
-            this.__key = referenceKey(this.isForward, ordinals.referenceTypeOrdinal(this.referenceType), nodeIdKey(this.nodeId));
+        if (this._key === undefined) {
+            this._key = referenceKey(this.isForward, ordinals.referenceTypeOrdinal(this.referenceType), nodeIdKey(this.nodeId));
         }
-        return this.__key;
+        return this._key;
     }
 
     /**
@@ -230,7 +231,7 @@ export class ReferenceImpl implements UAReference {
      */
     public dispose(): void {
         this.__hash = undefined;
-        this.__key = undefined;
+        // _key stays: the index holding this reference finds it by that key (ReferenceIndex)
         this.node = undefined;
         /*
         this._referenceType = null;

package/impl/reference_index.ts

@@ -0,0 +1,116 @@
+import type { UAReference } from "node-opcua-address-space-base";
+import type { ReferenceImpl, ReferenceKey } from "./reference_impl.js";
+
+/**
+ * above this many references a node indexes them in a Map; below, a plain array scanned on
+ * lookup. A leaf node holds two or three references, and a Map with its hash table costs
+ * about 280 bytes even when nearly empty: a quarter of what a node weighs. On a model of a
+ * million nodes that is the difference between fitting in memory and not.
+ */
+const MAP_THRESHOLD = 16;
+
+/**
+ * The references a node holds, by key (see ReferenceImpl#key). It offers what the code uses of
+ * a Map: get, has, set, delete, values, size and iteration.
+ *
+ * The key is not stored twice: a reference caches its own key when it is indexed, and a scan
+ * compares that cached key.
+ */
+export class ReferenceIndex {
+    #refs: UAReference[] | null = null;
+    #map: Map<ReferenceKey, UAReference> | null = null;
+
+    public get size(): number {
+        return this.#map ? this.#map.size : this.#refs ? this.#refs.length : 0;
+    }
+
+    #indexOf(key: ReferenceKey): number {
+        const refs = this.#refs as ReferenceImpl[];
+        for (let i = 0; i < refs.length; i++) {
+            if (refs[i]._key === key) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public has(key: ReferenceKey): boolean {
+        if (this.#map) {
+            return this.#map.has(key);
+        }
+        return this.#refs !== null && this.#indexOf(key) !== -1;
+    }
+
+    public get(key: ReferenceKey): UAReference | undefined {
+        if (this.#map) {
+            return this.#map.get(key);
+        }
+        if (this.#refs === null) {
+            return undefined;
+        }
+        const index = this.#indexOf(key);
+        return index === -1 ? undefined : this.#refs[index];
+    }
+
+    /** `key` must be the reference's own key (ReferenceImpl#key), which is what callers index by */
+    public set(key: ReferenceKey, reference: UAReference): this {
+        if (this.#map) {
+            this.#map.set(key, reference);
+            return this;
+        }
+        if (this.#refs === null) {
+            this.#refs = [reference];
+            return this;
+        }
+        const index = this.#indexOf(key);
+        if (index !== -1) {
+            this.#refs[index] = reference; // check-proto-pollution: ok - numeric index
+            return this;
+        }
+        if (this.#refs.length >= MAP_THRESHOLD) {
+            const map = new Map<ReferenceKey, UAReference>();
+            for (const ref of this.#refs) {
+                map.set((ref as ReferenceImpl)._key as ReferenceKey, ref);
+            }
+            map.set(key, reference);
+            this.#map = map;
+            this.#refs = null;
+            return this;
+        }
+        // concat allocates exactly the length needed; push would grow the backing store to 17
+        // slots, which is more than the Map this replaces
+        this.#refs = this.#refs.concat(reference);
+        return this;
+    }
+
+    public delete(key: ReferenceKey): boolean {
+        if (this.#map) {
+            return this.#map.delete(key);
+        }
+        if (this.#refs === null) {
+            return false;
+        }
+        const index = this.#indexOf(key);
+        if (index === -1) {
+            return false;
+        }
+        this.#refs = this.#refs.length === 1 ? null : this.#refs.filter((_r, i) => i !== index);
+        return true;
+    }
+
+    public clear(): void {
+        this.#refs = null;
+        this.#map = null;
+    }
+
+    public values(): IterableIterator<UAReference> {
+        if (this.#map) {
+            return this.#map.values();
+        }
+        return (this.#refs ?? []).values();
+    }
+
+    public [Symbol.iterator](): IterableIterator<UAReference> {
+        return this.values();
+    }
+}