modtool/src/ua/UAObjectType.ts

import { XMLElem } from "@/util/XmlElem";
import type { NamespaceTable } from "./NameSpaceTable";
import { UABaseNode, type UABaseNodeOptions } from "./UABaseNode";
import type { UAObject } from "./UAObject";
import type { UAVariable } from "./UAVariable";




export class UAObjectType extends UABaseNode{
    public isAbstract: boolean;
  

    constructor(options: UAObjectTypeOptions) {
        super(options)
        this.isAbstract=options.isAbstract||false;
    }

    static  fromXML(xmlObjType: any): UAObjectType{
        const bn=super.fromXML(xmlObjType)
        return new UAObjectType({nodeId: bn.nodeId, 
                            browseName: bn.browseName, 
                            displayName: bn.displayName,
                            references: bn.references,
                            isAbstract: xmlObjType['@_IsAbstract']==='true'});
    }

    toXML(lnst:NamespaceTable, gnst:NamespaceTable): XMLElem {
        const nid=UABaseNode.localNodeId(this.nodeId, lnst, gnst);
        const elem =new XMLElem('UAObjectType');
        elem.attr('NodeId', nid.toString())
            .attr('BrowseName', this.browseName)
            .attr('IsAbstract', this.isAbstract)
            .elem('DisplayName', this.displayName);
        const refs=elem.add(new XMLElem('References'))
        for(const ref of this.references) {
            if(ref.fromNode.nodeId.toString()==this.nodeId.toString()) //on load resolveReferences() duplicates references to both sides. skip them for export
                refs.add(ref.toXML(lnst, gnst));
        }
        return elem;
    }

    getModellingRule(){
        let res:any = "";
        this.references.forEach((ref)=>{
            if(ref.referenceType == "HasModellingRule"){
                res = ref.toNode.displayName;
            }
        })
        return res;
    }

}

export interface UAObjectTypeOptions extends UABaseNodeOptions{
    isAbstract?: boolean
}