node-opcua-address-space 2.180.0 → 2.181.1

package/impl/event_layout.ts

@@ -0,0 +1,141 @@
+/**
+ * @module node-opcua-address-space.Private
+ *
+ * The layout of an event: which fields an event of a given type carries, where each one sits in the
+ * type hierarchy and under which name `raiseEvent`'s caller provides its value. Raising an event
+ * used to rediscover this by browsing the event type and its supertypes; the layout is now built
+ * once per event type and rebuilt only when one of the nodes it was read from changes.
+ */
+import type { BaseNode, IAddressSpace, UAObjectType } from "node-opcua-address-space-base";
+import { NodeClass } from "node-opcua-data-model";
+import { type NodeId, sameNodeId } from "node-opcua-nodeid";
+import { lowerFirstLetter } from "node-opcua-utils";
+import { BaseNode_getCache } from "./base_node_private.js";
+
+export interface EventField {
+    /** the key under which the caller of raiseEvent gives the value: `"enabledState.id"` */
+    lowerName: string;
+    /** the browse path of the field from the event type: `"EnabledState.Id"` */
+    fullBrowsePath: string;
+    node: BaseNode;
+    /** `node.nodeId.toString()`, the key under which a select clause reads the value back */
+    nodeIdKey: string;
+    mandatory: boolean;
+}
+
+interface Dependency {
+    node: BaseNode;
+    /** the node's cache object when the layout was built; a change to the node replaces it */
+    cache: object;
+}
+
+export interface EventLayout {
+    fields: EventField[];
+    /** every `lowerName`, to tell a caller which of its keys name no field */
+    names: Set<string>;
+    /** browse path to field NodeId, shared by every event raised with this layout */
+    pathToNodeId: Map<string, NodeId>;
+    dependencies: Dependency[];
+}
+
+const layouts = new WeakMap<UAObjectType, EventLayout>();
+
+/**
+ * a layout stays valid while none of the nodes it was read from (the event type, its supertypes
+ * below BaseObjectType, and their direct children) gained or lost a reference: each of those
+ * clears its cache object, and the layout remembers the ones it saw
+ */
+function isValid(layout: EventLayout): boolean {
+    for (const dependency of layout.dependencies) {
+        if (BaseNode_getCache(dependency.node) !== dependency.cache) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function buildEventLayout(addressSpace: IAddressSpace, eventType: UAObjectType, baseObjectType: UAObjectType): EventLayout {
+    // supertypes first, as before: when two types declare the same name the base one wins
+    const chain: UAObjectType[] = [];
+    let type: UAObjectType | null = eventType;
+    while (type && !sameNodeId(type.nodeId, baseObjectType.nodeId)) {
+        chain.push(type);
+        const baseTypeNodeId = type.subtypeOf;
+        /* c8 ignore next */
+        if (!baseTypeNodeId) {
+            throw new Error(`Object ${type.browseName.toString()} with nodeId ${type.nodeId} has no Type`);
+        }
+        const baseType = addressSpace.findNode(baseTypeNodeId) as UAObjectType | null;
+        /* c8 ignore next */
+        if (!baseType) {
+            throw new Error(`Cannot find object with nodeId ${baseTypeNodeId}`);
+        }
+        type = baseType;
+    }
+    chain.reverse();
+
+    const layout: EventLayout = {
+        fields: [],
+        names: new Set<string>(),
+        pathToNodeId: new Map<string, NodeId>(),
+        dependencies: []
+    };
+    const depend = (node: BaseNode) => layout.dependencies.push({ node, cache: BaseNode_getCache(node) });
+
+    const addField = (prefixLower: string, prefixStandard: string, node: BaseNode) => {
+        const lowerName = prefixLower + lowerFirstLetter(node.browseName?.name || "");
+        if (layout.names.has(lowerName)) {
+            return;
+        }
+        const fullBrowsePath = prefixStandard + node.browseName.toString();
+        layout.names.add(lowerName);
+        layout.pathToNodeId.set(fullBrowsePath, node.nodeId);
+        layout.fields.push({
+            lowerName,
+            fullBrowsePath,
+            node,
+            nodeIdKey: node.nodeId.toString(),
+            mandatory: node.modellingRule === "Mandatory"
+        });
+    };
+
+    for (const self of chain) {
+        depend(self);
+        const children = ([] as BaseNode[]).concat(self.getProperties(), self.getComponents());
+        for (const node of children) {
+            // a child without a modelling rule may gain one later: watch it too
+            depend(node);
+            if (!node.modellingRule || node.nodeClass === NodeClass.Method) {
+                continue;
+            }
+            addField("", "", node);
+            const aggregates = node.getAggregates();
+            if (aggregates.length > 0) {
+                const lowerName = lowerFirstLetter(node.browseName.name || "");
+                const standardName = node.browseName.toString();
+                for (const child of aggregates) {
+                    addField(`${lowerName}.`, `${standardName}.`, child);
+                }
+            }
+        }
+    }
+    return layout;
+}
+
+/**
+ * the layout of events of the given type, built on first use and after a change to the type hierarchy
+ */
+export function getEventLayout(addressSpace: IAddressSpace, eventType: UAObjectType, baseObjectType: UAObjectType): EventLayout {
+    const cached = layouts.get(eventType);
+    if (cached && isValid(cached)) {
+        return cached;
+    }
+    const layout = buildEventLayout(addressSpace, eventType, baseObjectType);
+    layouts.set(eventType, layout);
+    return layout;
+}
+
+/** for tests: the cached layout of an event type, if any, without rebuilding it */
+export function peekEventLayout(eventType: UAObjectType): EventLayout | undefined {
+    return layouts.get(eventType);
+}

package/impl/extension_object_array_node.ts

@@ -0,0 +1,343 @@
+/**
+ * @module node-opcua-address-space.Private
+ */
+
+import type { BindVariableOptionsVariation1, UADynamicVariableArray, UAObject, UAVariable } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { BrowseDirection, NodeClass, type QualifiedName, type QualifiedNameLike } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { ExtensionObject } from "node-opcua-extension-object";
+import type { NodeId } from "node-opcua-nodeid";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+import { UAVariableImpl } from "./ua_variable_impl.js";
+
+const _doDebug = checkDebugFlag("extension_object_array_node");
+const _debugLog = make_debugLog("extension_object_array_node");
+const errorLog = make_errorLog("extension_object_array_node");
+const warningLog = make_warningLog("extension_object_array_node");
+
+/*
+ * define a complex Variable containing a array of extension objects
+ * each element of the array is also accessible as a component variable.
+ *
+ */
+
+function getExtObjArrayNodeValue<T extends ExtensionObject>(this: UADynamicVariableArray<T>) {
+    return new Variant({
+        arrayType: VariantArrayType.Array,
+        dataType: DataType.ExtensionObject,
+        value: this.$$extensionObjectArray
+    });
+}
+
+function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, elementIndex: number) {
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+
+    assert(typeof elementIndex === "number");
+
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const extObj = _array[elementIndex];
+    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj, elementIndex);
+
+    // remove element from global array (inefficient)
+    uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
+    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
+        //    throw new Error("internal error");
+    }
+    uaArrayVariableNode.touchValue();
+
+    // remove matching component
+    const node = uaArrayVariableNode.getComponentByName(browseName);
+    if (!node) {
+        throw new Error(" cannot find component ");
+    }
+
+    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent");
+    // c8 ignore next
+    if (!hasComponent) {
+        throw new Error("cannot find HasComponent reference type: please check your nodeset file");
+    }
+
+    // remove the hasComponent reference toward node
+    uaArrayVariableNode.removeReference({
+        isForward: true,
+        nodeId: node.nodeId,
+        referenceType: hasComponent.nodeId
+    });
+
+    // now check if node has still some parent
+    const parents = node.findReferencesEx("HasChild", BrowseDirection.Inverse);
+    if (parents.length === 0) {
+        addressSpace.deleteNode(node.nodeId);
+    }
+}
+
+export interface CreateExtObjArrayNodeOptions {
+    browseName: QualifiedNameLike;
+    complexVariableType: string | NodeId;
+    variableType: string | NodeId;
+    indexPropertyName: string;
+    minimumSamplingInterval?: number;
+}
+
+/**
+ *
+ * create a node Variable that contains a array of ExtensionObject of a given type
+ */
+export function createExtObjArrayNode<T extends ExtensionObject>(
+    parentFolder: UAObject,
+    options: CreateExtObjArrayNodeOptions
+): UADynamicVariableArray<T> {
+    assert(typeof options.variableType === "string");
+    assert(typeof options.indexPropertyName === "string");
+
+    const addressSpace = parentFolder.addressSpace;
+    const namespace = parentFolder.namespace;
+
+    const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
+    // c8 ignore next
+    if (!complexVariableType) {
+        throw new Error("cannot find complex variable type");
+    }
+    assert(!complexVariableType.nodeId.isEmpty());
+
+    const variableType = addressSpace.findVariableType(options.variableType);
+    if (!variableType) {
+        throw new Error("cannot find variable Type");
+    }
+    assert(!variableType.nodeId.isEmpty());
+
+    const structure = addressSpace.findDataType("Structure");
+    // c8 ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
+
+    const dataType = addressSpace.findDataType(variableType.dataType);
+
+    // c8 ignore next
+    if (!dataType) {
+        errorLog(variableType.toString());
+        throw new Error("cannot find Data Type");
+    }
+
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+
+    const inner_options = {
+        componentOf: parentFolder,
+
+        browseName: options.browseName,
+        dataType: dataType.nodeId,
+        typeDefinition: complexVariableType.nodeId,
+        value: { dataType: DataType.ExtensionObject, value: [], arrayType: VariantArrayType.Array },
+        valueRank: 1
+    };
+
+    const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray<T>;
+
+    if (options.minimumSamplingInterval !== undefined) {
+        uaArrayVariableNode.minimumSamplingInterval = options.minimumSamplingInterval;
+    }
+
+    bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
+
+    return uaArrayVariableNode;
+}
+
+function _getElementBrowseName<T extends ExtensionObject>(
+    this: UADynamicVariableArray<T>,
+    extObj: ExtensionObject,
+    _index: number | number[]
+) {
+    const indexPropertyName1 = this.$$indexPropertyName;
+
+    if (!Object.hasOwn(extObj, indexPropertyName1)) {
+        warningLog(" extension object does not have ", indexPropertyName1, extObj);
+    }
+    // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
+    assert(Object.hasOwn(extObj, indexPropertyName1));
+    const browseName = (extObj as unknown as Record<string, { toString(): string }>)[indexPropertyName1].toString();
+    return browseName;
+}
+
+export function bindExtObjArrayNode<T extends ExtensionObject>(
+    uaArrayVariableNode: UADynamicVariableArray<T>,
+    variableTypeNodeId: string | NodeId,
+    indexPropertyName: string
+): UAVariable {
+    assert(uaArrayVariableNode.valueRank === 1, "expecting a one dimension array");
+
+    const addressSpace = uaArrayVariableNode.addressSpace;
+
+    const variableType = addressSpace.findVariableType(variableTypeNodeId);
+    // c8 ignore next
+    if (!variableType || variableType.nodeId.isEmpty()) {
+        throw new Error(`Cannot find VariableType ${variableTypeNodeId.toString()}`);
+    }
+
+    const structure = addressSpace.findDataType("Structure");
+    // c8 ignore next
+    if (!structure) {
+        throw new Error("Structure Type not found: please check your nodeset file");
+    }
+
+    let dataType = addressSpace.findDataType(variableType.dataType);
+    // c8 ignore next
+    if (!dataType) {
+        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
+    }
+
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+
+    assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
+
+    uaArrayVariableNode.$$variableType = variableType;
+
+    // verify that an object with same doesn't already exist
+    dataType = addressSpace.findDataType(variableType.dataType);
+    // c8 ignore next
+    if (!dataType) {
+        throw new Error(`Cannot find DataType ${variableType.dataType.toString()}`);
+    }
+    assert(dataType.isSubtypeOf(structure), "expecting a structure (= ExtensionObject) here ");
+    assert(!uaArrayVariableNode.$$extensionObjectArray, "UAVariable ExtensionObject array already bounded");
+    uaArrayVariableNode.$$dataType = dataType;
+    uaArrayVariableNode.$$extensionObjectArray = [];
+    uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
+    // _getElementBrowseName actually returns a plain string (used opaquely via .toString() by every
+    // caller), while the base interface declares QualifiedName — cast to preserve exact prior runtime behavior.
+    uaArrayVariableNode.$$getElementBrowseName = _getElementBrowseName as unknown as (obj: T, index: number) => QualifiedName;
+    uaArrayVariableNode.$dataValue.value.value = uaArrayVariableNode.$$extensionObjectArray;
+    uaArrayVariableNode.$dataValue.value.arrayType = VariantArrayType.Array;
+
+    const bindOptions: BindVariableOptionsVariation1 = {
+        // getExtObjArrayNodeValue is generic over `this: UADynamicVariableArray<T>`, narrower than GetFunc's `this: UAVariable`
+        get: getExtObjArrayNodeValue as unknown as BindVariableOptionsVariation1["get"],
+        set: undefined // readonly
+    };
+    // bind the readonly
+    uaArrayVariableNode.bindVariable(bindOptions, true);
+    return uaArrayVariableNode;
+}
+
+/**
+
+ * add a new element in a ExtensionObject Array variable
+ * @param options {Object}   data used to construct the underlying ExtensionObject
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ *
+ */
+/**
+ * Takes the published UAVariable rather than UAVariableImpl.
+ *
+ * This function is exported from the package entry while UAVariableImpl is not, so naming the
+ * implementation class here made the first overload uncallable from outside - and from the
+ * package's own tests, which hold public types. The `instanceof UAVariableImpl` below still
+ * narrows it at run time; that check is what decides the branch, not the declared type.
+ */
+export function addElement<T extends ExtensionObject>(
+    options: UAVariable | ExtensionObject | Record<string, unknown>,
+    uaArrayVariableNode: UADynamicVariableArray<T>
+): UAVariable {
+    assert(uaArrayVariableNode, " must provide an UAVariable containing the array");
+    // verify that arr has been created correctly
+    assert(
+        !!uaArrayVariableNode.$$variableType && !!uaArrayVariableNode.$$dataType,
+        "did you create the array Node with createExtObjArrayNode ?"
+    );
+    assert(uaArrayVariableNode.$$dataType.nodeClass === NodeClass.DataType);
+
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const Constructor = addressSpace.getExtensionObjectConstructor(uaArrayVariableNode.$$dataType);
+    assert(Constructor instanceof Function);
+
+    let extensionObject: T;
+    let elVar = null;
+    let browseName: QualifiedName;
+
+    if (options instanceof UAVariableImpl) {
+        elVar = options;
+        extensionObject = elVar.$extensionObject; // get shared extension object
+
+        assert(
+            extensionObject instanceof Constructor,
+            "the provided variable must expose a Extension Object of the expected type "
+        );
+        // add a reference
+        uaArrayVariableNode.addReference({
+            isForward: true,
+            nodeId: elVar.nodeId,
+            referenceType: "HasComponent"
+        });
+        // xx elVar.bindExtensionObject();
+    } else {
+        if (options instanceof ExtensionObject) {
+            // extension object has already been created
+            extensionObject = options as T;
+        } else {
+            // `instanceof UAVariableImpl` above narrows the class out of the union but not the
+            // UAVariable interface, since a UAVariable need not be that class. Whatever is left
+            // here is the plain options record that constructExtensionObject takes.
+            const optionsRecord = options as Record<string, unknown>;
+            extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, optionsRecord) as T;
+        }
+        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 });
+    }
+
+    if (uaArrayVariableNode.$$extensionObjectArray !== uaArrayVariableNode.$dataValue.value.value) {
+        //    throw new Error("internal error");
+    }
+    // also add the value inside
+    uaArrayVariableNode.$$extensionObjectArray.push(elVar.$extensionObject);
+    uaArrayVariableNode.touchValue();
+
+    return elVar;
+}
+
+/**
+ *
+ */
+export function removeElement<T extends ExtensionObject>(
+    uaArrayVariableNode: UADynamicVariableArray<T>,
+    element: number | UAVariable | ((a: T) => boolean)
+): void {
+    assert(element, "removeElement: element must exist");
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+
+    // c8 ignore next
+    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?.nodeClass) {
+        // find element by name
+        const browseNameToFind = element.browseName.name?.toString();
+        elementIndex = _array.findIndex((obj: T, _i: number) => {
+            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj, elementIndex).toString();
+            return browseName === browseNameToFind;
+        });
+    } else {
+        throw new Error("Unsupported anymore!!! please use a functor instead");
+    }
+
+    // c8 ignore next
+    if (elementIndex < 0) {
+        throw new Error(`removeElement: cannot find element matching ${element.toString()}`);
+    }
+    removeElementByIndex(uaArrayVariableNode, elementIndex);
+}

package/impl/handle_hierarchy_parent.ts

@@ -0,0 +1,133 @@
+/**
+ * @module node-opcua-address-space
+ *
+ * Extracted from namespace_impl.ts to break an import cycle.
+ *
+ * namespace_impl builds `_constructors_map` at module scope, which references
+ * UAMethodImpl and seven sibling constructors. ua_method_impl imported
+ * _handle_hierarchy_parent back from namespace_impl, closing the loop.
+ *
+ * Under CommonJS that is harmless: whichever module loads second sees a partially
+ * populated exports object, and nothing touches the missing half until a function runs.
+ * Under ESM the class declarations are in the temporal dead zone while the cycle is being
+ * evaluated, so building a map of constructors at module scope throws a ReferenceError.
+ *
+ * This module depends only on base_node_impl and leaf packages, so nothing points back
+ * into namespace_impl and the cycle is gone rather than moved.
+ */
+
+import type { AddReferenceOpts, BaseNode } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId, type NodeIdLike } from "node-opcua-nodeid";
+import type { AddressSpacePrivate } from "./address_space_private.js";
+import { BaseNodeImpl } from "./base_node_impl.js";
+
+/**
+ * convert a 'string', NodeId or Object into a valid and existing object
+ * @private
+ */
+export function _coerce_parent(
+    addressSpace: AddressSpacePrivate,
+    value: null | string | BaseNode | undefined | NodeIdLike,
+    coerceFunc: (data: string | NodeId | BaseNode) => BaseNode | null
+): BaseNode | null {
+    assert(typeof coerceFunc === "function");
+    if (value) {
+        if (typeof value === "string") {
+            value = coerceFunc.call(addressSpace, value);
+        }
+        if (value instanceof NodeId) {
+            value = addressSpace.findNode(value) as BaseNode;
+        }
+    }
+    assert(!value || value instanceof BaseNodeImpl);
+    return value as BaseNode;
+}
+
+export interface HandleHierarchyParentOptions {
+    addInOf?: NodeIdLike | BaseNode | null | undefined;
+    componentOf?: NodeIdLike | BaseNode | null | undefined;
+    propertyOf?: NodeIdLike | BaseNode | null | undefined;
+    organizedBy?: NodeIdLike | BaseNode | null | undefined;
+    encodingOf?: NodeIdLike | BaseNode | null | undefined;
+}
+
+export function _handle_hierarchy_parent(
+    addressSpace: AddressSpacePrivate,
+    references: AddReferenceOpts[],
+    options: HandleHierarchyParentOptions
+): void {
+    options.addInOf = _coerce_parent(addressSpace, options.addInOf, addressSpace._coerceNode);
+    options.componentOf = _coerce_parent(addressSpace, options.componentOf, addressSpace._coerceNode);
+    options.propertyOf = _coerce_parent(addressSpace, options.propertyOf, addressSpace._coerceNode);
+    options.organizedBy = _coerce_parent(addressSpace, options.organizedBy, addressSpace._coerceFolder);
+    options.encodingOf = _coerce_parent(addressSpace, options.encodingOf, addressSpace._coerceNode);
+
+    if (options.addInOf) {
+        assert(!options.componentOf);
+        assert(!options.propertyOf);
+        assert(!options.organizedBy);
+        assert(
+            options.addInOf.nodeClass === NodeClass.Object || options.addInOf.nodeClass === NodeClass.ObjectType,
+            "addInOf must be of nodeClass Object or ObjectType"
+        );
+        references.push({
+            isForward: false,
+            nodeId: options.addInOf.nodeId,
+            referenceType: "HasAddIn"
+        });
+    }
+
+    if (options.componentOf) {
+        assert(!options.addInOf);
+        assert(!options.propertyOf);
+        assert(!options.organizedBy);
+        assert(addressSpace.rootFolder.objects, "addressSpace must have a rootFolder.objects folder");
+        assert(
+            options.componentOf.nodeId !== addressSpace.rootFolder.objects.nodeId,
+            "Only Organizes References are used to relate Objects to the 'Objects' standard Object."
+        );
+        references.push({
+            isForward: false,
+            nodeId: options.componentOf.nodeId,
+            referenceType: "HasComponent"
+        });
+    }
+
+    if (options.propertyOf) {
+        assert(!options.addInOf);
+        assert(!options.componentOf);
+        assert(!options.organizedBy);
+        assert(
+            options.propertyOf.nodeId !== addressSpace.rootFolder.objects.nodeId,
+            "Only Organizes References are used to relate Objects to the 'Objects' standard Object."
+        );
+        references.push({
+            isForward: false,
+            nodeId: options.propertyOf.nodeId,
+            referenceType: "HasProperty"
+        });
+    }
+
+    if (options.organizedBy) {
+        assert(!options.addInOf);
+        assert(!options.propertyOf);
+        assert(!options.componentOf);
+        references.push({
+            isForward: false,
+            nodeId: options.organizedBy.nodeId,
+            referenceType: "Organizes"
+        });
+    }
+
+    if (options.encodingOf) {
+        // parent must be a DataType
+        assert(options.encodingOf.nodeClass === NodeClass.DataType, "encodingOf must be toward a DataType");
+        references.push({
+            isForward: false,
+            nodeId: options.encodingOf.nodeId,
+            referenceType: "HasEncoding"
+        });
+    }
+}