node-opcua-address-space 2.87.0 → 2.89.0

package/src/extension_object_array_node.ts

@@ -13,6 +13,7 @@ import { VariantArrayType } from "node-opcua-variant";
 import { ExtensionObject } from "node-opcua-extension-object";
 import { UADataType, UADynamicVariableArray, UAObject, UAReferenceType, UAVariable } from "node-opcua-address-space-base";
 import { UAVariableImpl } from "./ua_variable_impl";
+import { getProxyTarget } from "./ua_variable_impl_ext_obj";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -23,7 +24,7 @@ const errorLog = make_errorLog(__filename);
  *
  */
 
-function getExtObjArrayNodeValue<T  extends ExtensionObject>(this: UADynamicVariableArray<T>) {
+function getExtObjArrayNodeValue<T extends ExtensionObject>(this: UADynamicVariableArray<T>) {
     return new Variant({
         arrayType: VariantArrayType.Array,
         dataType: DataType.ExtensionObject,
@@ -38,7 +39,7 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
 
     const addressSpace = uaArrayVariableNode.addressSpace;
     const extObj = _array[elementIndex];
-    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj);
+    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj, elementIndex);
 
     // remove element from global array (inefficient)
     uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
@@ -68,14 +69,6 @@ function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UA
 /**
  *
  * create a node Variable that contains a array of ExtensionObject of a given type
- * @method createExtObjArrayNode
- * @param parentFolder
- * @param options
- * @param options.browseName
- * @param options.complexVariableType
- * @param options.variableType        the type of Extension objects stored in the array.
- * @param options.indexPropertyName
- * @return {Object|UAVariable}
  */
 export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T> {
     assert(typeof options.variableType === "string");
@@ -126,7 +119,9 @@ export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: U
 
     return uaArrayVariableNode;
 }
-function _getElementBrowseName<T extends ExtensionObject>(this: UADynamicVariableArray<T>, extObj: ExtensionObject) {
+
+function _getElementBrowseName<T extends ExtensionObject>
+    (this: UADynamicVariableArray<T>, extObj: ExtensionObject, index: number | number[]) {
     const indexPropertyName1 = this.$$indexPropertyName;
 
     if (!Object.prototype.hasOwnProperty.call(extObj, indexPropertyName1)) {
@@ -137,13 +132,7 @@ function _getElementBrowseName<T extends ExtensionObject>(this: UADynamicVariabl
     const browseName = (extObj as any)[indexPropertyName1].toString();
     return browseName;
 };
-/**
- * @method bindExtObjArrayNode
- * @param uaArrayVariableNode
- * @param variableTypeNodeId
- * @param indexPropertyName
- * @return
- */
+
 export function bindExtObjArrayNode<T extends ExtensionObject>(
     uaArrayVariableNode: UADynamicVariableArray<T>,
     variableTypeNodeId: string | NodeId,
@@ -155,26 +144,23 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     const addressSpace = uaArrayVariableNode.addressSpace;
 
     const variableType = addressSpace.findVariableType(variableTypeNodeId);
-    
     // istanbul ignore next
     if (!variableType || variableType.nodeId.isEmpty()) {
         throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
     }
 
     const structure = addressSpace.findDataType("Structure");
-
     // istanbul ignore next
     if (!structure) {
         throw new Error("Structure Type not found: please check your nodeset file");
     }
 
     let dataType = addressSpace.findDataType(variableType.dataType);
-    
     // istanbul ignore next
     if (!dataType) {
         throw new Error("Cannot find DataType " + variableType.dataType.toString());
     }
-    
+
     assert(dataType.isSupertypeOf(structure), "expecting a structure (= ExtensionObject) here ");
 
     assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
@@ -197,7 +183,6 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
     };
     // bind the readonly
     uaArrayVariableNode.bindVariable(bindOptions, true);
-
     return uaArrayVariableNode;
 }
 
@@ -208,20 +193,9 @@ export function bindExtObjArrayNode<T extends ExtensionObject>(
  * @param uaArrayVariableNode {UAVariable}
  * @return {UAVariable}
  *
- * @method addElement
- * add a new element in a ExtensionObject Array variable
- * @param nodeVariable a variable already exposing an extension objects
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
- *
- * @method addElement
- * add a new element in a ExtensionObject Array variable
- * @param constructor  constructor of the extension object to create
- * @param uaArrayVariableNode {UAVariable}
- * @return {UAVariable}
  */
 export function addElement<T extends ExtensionObject>(
-    options: any /* ExtensionObjectConstructor | ExtensionObject | UAVariable*/,
+    options: UAVariableImpl | ExtensionObject | Record<string, unknown>,
     uaArrayVariableNode: UADynamicVariableArray<T>
 ): UAVariable {
     assert(uaArrayVariableNode, " must provide an UAVariable containing the array");
@@ -256,20 +230,20 @@ export function addElement<T extends ExtensionObject>(
         });
         // xx elVar.bindExtensionObject();
     } else {
-        if (options instanceof Constructor) {
+        if (options instanceof ExtensionObject) {
             // extension object has already been created
             extensionObject = options as T;
         } else {
             extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options) as T;
         }
-        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject);
+        const index = uaArrayVariableNode.$$extensionObjectArray?.length || 0;
+        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject, index);
         elVar = uaArrayVariableNode.$$variableType.instantiate({
             browseName,
             componentOf: uaArrayVariableNode.nodeId,
             value: { dataType: DataType.ExtensionObject, value: extensionObject }
         }) as UAVariableImpl;
-        elVar.bindExtensionObject(extensionObject,  { force: true });
-        elVar.$extensionObject = extensionObject;
+        elVar.bindExtensionObject(extensionObject, { force: true });
     }
 
     // also add the value inside
@@ -279,24 +253,11 @@ export function addElement<T extends ExtensionObject>(
 }
 
 /**
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {number}   index of element to remove in array
- *
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {UAVariable}   node of element to remove in array
- *
- * @method removeElement
- * @param uaArrayVariableNode {UAVariable}
- * @param element {ExtensionObject}   extension object of the node of element to remove in array
  *
  */
 export function removeElement<T extends ExtensionObject>(
     uaArrayVariableNode: UADynamicVariableArray<T>,
-    element: any /* number | UAVariable | (a any) => boolean | ExtensionObject */
+    element: number | UAVariable | ((a: T) => boolean)
 ): void {
     assert(element, "removeElement: element must exist");
     const _array = uaArrayVariableNode.$$extensionObjectArray;
@@ -305,29 +266,30 @@ export function removeElement<T extends ExtensionObject>(
     if (_array.length === 0) {
         throw new Error(" cannot remove an element from an empty array ");
     }
-    
     let elementIndex = -1;
-
     if (typeof element === "number") {
         // find element by index
         elementIndex = element;
         assert(elementIndex >= 0 && elementIndex < _array.length);
+    } else if (typeof element === "function") {
+        // find element by functor
+        elementIndex = _array.findIndex(element);
     } else if (element && element.nodeClass) {
         // find element by name
         const browseNameToFind = element.browseName.name!.toString();
         elementIndex = _array.findIndex((obj: any, i: number) => {
-            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj).toString();
+            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
             return browseName === browseNameToFind;
         });
-    } else if (typeof element === "function") {
-        // find element by functor
-        elementIndex = _array.findIndex(element);
     } else {
-        // find element by inner extension object
-        assert(_array[0].constructor.name === (element as any).constructor.name, "element must match");
-        elementIndex = _array.findIndex((x: any) => x === element);
+        throw new Error("Unsupported anymore!!! please use a functor instead");
+        // // find element by inner extension object
+        // assert(_array[0].constructor.name === (element as any).constructor.name, "element must match");
+        // // let unproxyfy
+        // const elementTarget = getProxyTarget(element);
+        // elementIndex = _array.findIndex((x: any) => getProxyTarget(x) === elementTarget);
     }
-    
+
     // istanbul ignore next
     if (elementIndex < 0) {
         throw new Error("removeElement: cannot find element matching " + element.toString());

package/src/idx_iterator.ts

@@ -0,0 +1,52 @@
+
+
+
+
+export class IndexIterator {
+
+    public current: number[] | null = null;
+    constructor(private limits: number[]) {
+        this.reset();
+    }
+    public reset() {
+        this.current = [];
+        for (let i = 0; i < this.limits.length; i++) {
+            this.current[i] = 0;
+        }
+    }
+    public increment() {
+        if (!this.current) return;
+
+
+        const increase = (n: number): boolean => {
+            if (n < 0) {
+                return false;
+            }
+            if (!this.current) return false;
+            if (this.current[n] + 1 >= this.limits[n]) {
+                if (n==0) {
+                    this.current = null;
+                    return false;
+                }
+                this.current[n] = 0;
+                return increase(n - 1);
+            }
+            this.current[n] = this.current[n] + 1;
+            return true;
+        }
+        const n = this.limits.length - 1;
+        if (!increase(n)) {
+            this.current = null;
+        }
+    }
+    public next(): number[] {
+        if (!this.current) {
+            throw new Error("Outof bond");
+        }
+        const r = [... this.current];
+        this.increment();
+        return r;
+    }
+
+
+}

package/src/ua_variable_impl.ts

@@ -28,7 +28,8 @@ import {
     AccessLevelFlag,
     makeAccessLevelFlag,
     AttributeIds,
-    isDataEncoding
+    isDataEncoding,
+    QualifiedName
 } from "node-opcua-data-model";
 import { extractRange, sameDataValue, DataValue, DataValueLike, DataValueT } from "node-opcua-data-value";
 import { coerceClock, getCurrentClock, PreciseClock } from "node-opcua-date-time";
@@ -84,11 +85,12 @@ import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl"
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 import {
     extractPartialData,
+    incrementElement,
     propagateTouchValueUpward,
-    setExtensionObjectValue,
+    setExtensionObjectPartialValue,
     _bindExtensionObject,
+    _bindExtensionObjectArrayOrMatrix,
     _installExtensionObjectBindingOnProperties,
-    _setExtensionObject,
     _touchValue
 } from "./ua_variable_impl_ext_obj";
 
@@ -482,8 +484,11 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             if (this._timestamped_get_func.length === 0) {
                 const dataValueOrPromise = (this._timestamped_get_func as VariableDataValueGetterSync)();
                 if (!Object.prototype.hasOwnProperty.call(dataValueOrPromise, "then")) {
-                    this.$dataValue = dataValueOrPromise as DataValue;
-                    this.verifyVariantCompatibility(this.$dataValue.value);
+                    if (dataValueOrPromise !== this.$dataValue) {
+                        // TO DO : is this necessary ? this may interfere with current use of $dataValue
+                        this.$dataValue = dataValueOrPromise as DataValue;
+                        this.verifyVariantCompatibility(this.$dataValue.value);
+                    }
                 } else {
                     errorLog("Unsupported: _timestamped_get_func returns a Promise !");
                 }
@@ -819,8 +824,8 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 if (this.$extensionObject) {
                     // we have an extension object already bound to this node
                     // the client is asking us to replace the object entierly by a new one
-                    const ext = dataValue.value.value;
-                    _setExtensionObject(this, ext);
+                    // const ext = dataValue.value.value;
+                    this._internal_set_dataValue(dataValue);
                     return;
                 }
             } else {
@@ -1457,49 +1462,62 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      */
     public installExtensionObjectVariables(): void {
         _installExtensionObjectBindingOnProperties(this, { createMissingProp: true });
-        // now recursively install extension object on children
-        for (const child of this.getComponents()) {
-            if (child.nodeClass === NodeClass.Variable && child instanceof UAVariableImpl) {
-                if (child.isExtensionObject()) {
-                    child.installExtensionObjectVariables();
-                }
-            }
-        }
     }
     /**
      * @method bindExtensionObject
      * @return {ExtensionObject}
      */
     public bindExtensionObjectScalar(
-        optionalExtensionObject: ExtensionObject,
+        optionalExtensionObject?: ExtensionObject,
         options?: BindExtensionObjectOptions
     ): ExtensionObject | null {
-        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject | null;
+        assert(this.valueRank === -1, "expecting an Scalar variable here");
+        return _bindExtensionObject(this, optionalExtensionObject, options) as ExtensionObject;
     }
 
     public bindExtensionObjectArray(
-        optionalExtensionObject: ExtensionObject[],
+        optionalExtensionObject?: ExtensionObject[],
         options?: BindExtensionObjectOptions
     ): ExtensionObject[] | null {
-        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject[] | null;
+        assert(this.valueRank >= 1, "expecting an Array or a Matrix variable here");
+        return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
     }
 
     public bindExtensionObject(
         optionalExtensionObject?: ExtensionObject | ExtensionObject[],
         options?: BindExtensionObjectOptions
     ): ExtensionObject | ExtensionObject[] | null {
-        return _bindExtensionObject(this, optionalExtensionObject, options);
+        if (optionalExtensionObject) {
+            if (optionalExtensionObject instanceof Array) {
+                assert(this.valueRank >= 1, "expecting an Array of Matrix variable here");
+                return _bindExtensionObjectArrayOrMatrix(this, optionalExtensionObject, options);
+            } else {
+                assert(this.valueRank === -1, "expecting an Scalar variable here");
+                return _bindExtensionObject(this, optionalExtensionObject, options) as ExtensionObject;
+            }
+        }
+        assert(optionalExtensionObject === undefined);
+        if (this.valueRank === -1) {
+            return _bindExtensionObject(this, undefined, options) as ExtensionObject;
+        } else if (this.valueRank === 1) {
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
+        } else if (this.valueRank > 1) {
+            return _bindExtensionObjectArrayOrMatrix(this, undefined, options);
+        }
+        //  unsupported case ... 
+        return null;
     }
 
     public updateExtensionObjectPartial(partialExtensionObject?: { [key: string]: any }): ExtensionObject {
-        setExtensionObjectValue(this, partialExtensionObject);
+        setExtensionObjectPartialValue(this, partialExtensionObject);
         return this.$extensionObject;
     }
 
     public incrementExtensionObjectPartial(path: string | string[]): void {
         const extensionObject = this.readValue().value.value as ExtensionObject;
         const partialData = extractPartialData(path, extensionObject);
-        setExtensionObjectValue(this, partialData);
+        incrementElement(path, partialData);
+        setExtensionObjectPartialValue(this, partialData);
     }
 
     public toString(): string {
@@ -1665,10 +1683,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         assert(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
 
         const addressSpace = this.addressSpace;
+
+        // istanbul ignore next
         if (!addressSpace) {
             warningLog("UAVariable#_internal_set_dataValue : no addressSpace ! may be node has already been deleted ?");
             return;
         }
+
+        // istanbul ignore next
         if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
@@ -1681,31 +1703,25 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 );
             }
         }
+
+        // istanbul ignore next
         if (dataValue.value.dataType === DataType.ExtensionObject) {
+            // istanbul ignore next
             if (!this.checkExtensionObjectIsCorrect(dataValue.value.value)) {
                 warningLog(dataValue.toString());
                 throw new Error("Invalid Extension Object on nodeId =" + this.nodeId.toString());
             }
-            // ----------------------------------
-            // if (this.$extensionObject) {
-            //     // we have an extension object already bound to this node
-            //     // the client is asking us to replace the object entierly by a new one
-            //     const ext = dataValue.value.value;
-            //     _setExtensionObject(this, ext);
-            //     return;
-            // }
         }
-        // // istanbul ignore next
-        // if (this.dataType.namespace === 0) {
-        //     if (this.dataType.value === DataType.LocalizedText && dataValue.value.dataType !== DataType.LocalizedText) {
-        //         const message = "Invalid dataValue provided (expecting a LocalizedText) but got " + dataValue.toString();
-        //         errorLog(message);
-        //         // throw new Error(message);
-        //     }
-        // }
-
+   
         this.verifyVariantCompatibility(dataValue.value);
 
+        this._inner_replace_dataValue(dataValue, indexRange);
+    }
+
+    /**
+     * @private
+     */
+    public _inner_replace_dataValue(dataValue: DataValue, indexRange?: NumericRange | null) {
         const old_dataValue = this.$dataValue;
 
         this.$dataValue = dataValue;
@@ -1830,14 +1846,15 @@ UAVariableImpl.prototype.writeAttribute = thenify.withCallback(UAVariableImpl.pr
 UAVariableImpl.prototype.historyRead = thenify.withCallback(UAVariableImpl.prototype.historyRead);
 UAVariableImpl.prototype.readValueAsync = thenify.withCallback(UAVariableImpl.prototype.readValueAsync);
 
-export interface UAVariableImpl {
-    $$variableType?: any;
-    $$dataType?: any;
-    $$getElementBrowseName: any;
-    $$extensionObjectArray: any;
-    $$indexPropertyName: any;
+export interface UAVariableImplExtArray {
+    $$variableType?: UAVariableType;
+    $$dataType: UADataType;
+    $$getElementBrowseName: (extObject: ExtensionObject, index: number | number[]) => QualifiedName;
+    $$extensionObjectArray: ExtensionObject[];
+    $$indexPropertyName: string;
+}
+export interface UAVariableImpl extends UAVariableImplExtArray {
 }
-
 function check_valid_array(dataType: DataType, array: any): boolean {
     if (Array.isArray(array)) {
         return true;
@@ -1978,9 +1995,6 @@ function _Variable_bind_with_async_refresh(this: UAVariableImpl, options: any) {
 
     this.refreshFunc = options.refreshFunc;
 
-    // assert(this.readValue().statusCode.equals(StatusCodes.BadNodeIdUnknown));
-    this.$dataValue.statusCode = StatusCodes.UncertainInitialValue;
-
     // TO DO : REVISIT THIS ASSUMPTION
     if (false && this.minimumSamplingInterval === 0) {
         // when a getter /timestamped_getter or async_getter is provided
@@ -2119,10 +2133,9 @@ function _Variable_bind_with_timestamped_set(
         set: undefined;
     }
 ) {
-    assert(typeof options.timestamped_set === "function");
     assert(
-        options.timestamped_set.length === 2,
-        "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){}"
+        options.timestamped_set.length === 2 || options.timestamped_set.length === 1,
+        "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}"
     );
     assert(!options.set, "should not specify set when timestamped_set_func exists ");
     this._timestamped_set_func = convertToCallbackFunction1<StatusCode, DataValue, UAVariable>(options.timestamped_set);
@@ -2221,6 +2234,3 @@ export interface UAVariableImplT<T, DT extends DataType> extends UAVariableImpl,
     writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, indexRange?: NumericRange | null): Promise<StatusCode>;
 }
 export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl { }
-// x TO DO
-// require("./data_access/ua_variable_data_access");
-// require("./historical_access/ua_variable_history");