//// Reference types // public ReferenceTypeState CreateAddReferenceType( string browseDisplayName, string inverseName, uint preferredNumId = 0, bool useZeroNS = false, NodeId sourceId = null) { // create node itself var x = new ReferenceTypeState(); x.BrowseName = browseDisplayName; x.DisplayName = browseDisplayName; x.InverseName = inverseName; x.Symmetric = false; x.IsAbstract = false; x.NodeId = nodeMgr.NewType(nodeMgr.SystemContext, AasUaBaseEntity.CreateMode.Type, x, preferredNumId); nodeMgr.AddPredefinedNode(nodeMgr.SystemContext, x); // set Subtype reference if (sourceId == null) { sourceId = new NodeId(32, 0); } nodeMgr.AddExternalReferencePublic(sourceId, ReferenceTypeIds.HasSubtype, false, x.NodeId, nodeMgrExternalReferences); // done return(x); }
/// <summary> /// Creates a new reference type. /// </summary> private ReferenceTypeState CreateReferenceType(NodeState parent, IDictionary <NodeId, IList <IReference> > externalReferences, string path, string name) { ReferenceTypeState type = new ReferenceTypeState(); type.SymbolicName = name; type.SuperTypeId = ReferenceTypeIds.NonHierarchicalReferences; type.NodeId = new NodeId(path, NamespaceIndex); type.BrowseName = new QualifiedName(name, NamespaceIndex); type.DisplayName = type.BrowseName.Name; type.WriteMask = AttributeWriteMask.None; type.UserWriteMask = AttributeWriteMask.None; type.IsAbstract = false; type.Symmetric = true; type.InverseName = name; IList <IReference> references = null; if (!externalReferences.TryGetValue(ReferenceTypeIds.NonHierarchicalReferences, out references)) { externalReferences[ReferenceTypeIds.NonHierarchicalReferences] = references = new List <IReference>(); } references.Add(new NodeStateReference(ReferenceTypeIds.HasSubtype, false, type.NodeId)); if (parent != null) { parent.AddReference(ReferenceTypes.Organizes, false, type.NodeId); type.AddReference(ReferenceTypes.Organizes, true, parent.NodeId); } AddPredefinedNode(SystemContext, type); return(type); }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { BaseObjectState trigger = new BaseObjectState(null); trigger.NodeId = new NodeId(1, NamespaceIndex); trigger.BrowseName = new QualifiedName("Trigger", NamespaceIndex); trigger.DisplayName = trigger.BrowseName.Name; trigger.TypeDefinitionId = ObjectTypeIds.BaseObjectType; // ensure trigger can be found via the server object. IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } trigger.AddReference(ReferenceTypeIds.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, trigger.NodeId)); PropertyState property = new PropertyState(trigger); property.NodeId = new NodeId(2, NamespaceIndex); property.BrowseName = new QualifiedName("Matrix", NamespaceIndex); property.DisplayName = property.BrowseName.Name; property.TypeDefinitionId = VariableTypeIds.PropertyType; property.ReferenceTypeId = ReferenceTypeIds.HasProperty; property.DataType = DataTypeIds.Int32; property.ValueRank = ValueRanks.TwoDimensions; property.ArrayDimensions = new ReadOnlyList <uint>(new uint[] { 2, 2 }); trigger.AddChild(property); // save in dictionary. AddPredefinedNode(SystemContext, trigger); ReferenceTypeState referenceType = new ReferenceTypeState(); referenceType.NodeId = new NodeId(3, NamespaceIndex); referenceType.BrowseName = new QualifiedName("IsTriggerSource", NamespaceIndex); referenceType.DisplayName = referenceType.BrowseName.Name; referenceType.InverseName = new LocalizedText("IsSourceOfTrigger"); referenceType.SuperTypeId = ReferenceTypeIds.NonHierarchicalReferences; if (!externalReferences.TryGetValue(ObjectIds.Server, out references)) { externalReferences[ObjectIds.Server] = references = new List <IReference>(); } trigger.AddReference(referenceType.NodeId, false, ObjectIds.Server); references.Add(new NodeStateReference(referenceType.NodeId, true, trigger.NodeId)); // save in dictionary. AddPredefinedNode(SystemContext, referenceType); } }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { LogHelper.Instance.Info(string.Format("CreateAddressSpace {0} start.", channel.Name)); BaseObjectState trigger = new BaseObjectState(null); trigger.NodeId = new NodeId(1, NamespaceIndex); trigger.BrowseName = new QualifiedName(channel.Name, NamespaceIndex); trigger.DisplayName = trigger.BrowseName.Name; trigger.TypeDefinitionId = ObjectTypeIds.BaseObjectType; // ensure trigger can be found via the server object. IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } trigger.AddReference(ReferenceTypeIds.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, trigger.NodeId)); LoadNodeList(trigger); // save in dictionary. AddPredefinedNode(SystemContext, trigger); ReferenceTypeState referenceType = new ReferenceTypeState(); referenceType.NodeId = new NodeId(3, NamespaceIndex); referenceType.BrowseName = new QualifiedName("IsTriggerSource", NamespaceIndex); referenceType.DisplayName = referenceType.BrowseName.Name; referenceType.InverseName = new LocalizedText("IsSourceOfTrigger"); referenceType.SuperTypeId = ReferenceTypeIds.NonHierarchicalReferences; if (!externalReferences.TryGetValue(ObjectIds.Server, out references)) { externalReferences[ObjectIds.Server] = references = new List <IReference>(); } trigger.AddReference(referenceType.NodeId, false, ObjectIds.Server); references.Add(new NodeStateReference(referenceType.NodeId, true, trigger.NodeId)); // save in dictionary. AddPredefinedNode(SystemContext, referenceType); LogHelper.Instance.Info("CreateAddressSpace."); } }
/// <summary> /// Converts a ReferenceDescription to an IReference. /// </summary> private IReference ToReference(ReferenceDescription reference) { if (reference.NodeId.IsAbsolute || reference.TypeDefinition.IsAbsolute) { return(new NodeStateReference(reference.ReferenceTypeId, !reference.IsForward, reference.NodeId)); } if (m_source != null && (reference.NodeId == ObjectIds.ObjectsFolder || reference.NodeId == ObjectIds.Server)) { return(new NodeStateReference(reference.ReferenceTypeId, !reference.IsForward, m_rootId)); } NodeState target = null; switch (reference.NodeClass) { case NodeClass.DataType: { target = new DataTypeState(); break; } case NodeClass.Method: { target = new MethodState(null); break; } case NodeClass.Object: { target = new BaseObjectState(null); break; } case NodeClass.ObjectType: { target = new BaseObjectTypeState(); break; } case NodeClass.ReferenceType: { target = new ReferenceTypeState(); break; } case NodeClass.Variable: { target = new BaseDataVariableState(null); break; } case NodeClass.VariableType: { target = new BaseDataVariableTypeState(); break; } case NodeClass.View: { target = new ViewState(); break; } } target.NodeId = m_mapper.ToLocalId((NodeId)reference.NodeId); target.BrowseName = m_mapper.ToLocalName(reference.BrowseName); target.DisplayName = reference.DisplayName; if (target is BaseInstanceState) { ((BaseInstanceState)target).TypeDefinitionId = m_mapper.ToLocalId((NodeId)reference.TypeDefinition); } return(new NodeStateReference(reference.ReferenceTypeId, !reference.IsForward, target)); }
/// <summary> /// Helper to create an ReferenceType-Node. Note: __NO__ NodeId is created by the default! /// Must be done by outer functionality!! /// </summary> /// <param name="browseDisplayName">Name displayed in the node tree</param> /// <param name="inverseName"></param> /// <param name="superTypeId">Preset the NodeId</param> /// <param name="presetNodeId">Preset the NodeId</param> /// <returns></returns> public static ReferenceTypeState CreateReferenceType( string browseDisplayName, string inverseName, NodeId superTypeId, NodeId presetNodeId = null) { // create node itself var x = new ReferenceTypeState(); x.BrowseName = browseDisplayName; x.DisplayName = browseDisplayName; x.InverseName = inverseName; x.Symmetric = false; x.IsAbstract = false; x.SuperTypeId = superTypeId; if (presetNodeId != null) { x.NodeId = presetNodeId; } return(x); }
/// <summary> /// Imports a node from the set. /// </summary> private NodeState Import(ISystemContext context, UANode node) { NodeState importedNode = null; NodeClass nodeClass = NodeClass.Unspecified; if (node is UAObject) { nodeClass = NodeClass.Object; } else if (node is UAVariable) { nodeClass = NodeClass.Variable; } else if (node is UAMethod) { nodeClass = NodeClass.Method; } else if (node is UAObjectType) { nodeClass = NodeClass.ObjectType; } else if (node is UAVariableType) { nodeClass = NodeClass.VariableType; } else if (node is UADataType) { nodeClass = NodeClass.DataType; } else if (node is UAReferenceType) { nodeClass = NodeClass.ReferenceType; } else if (node is UAView) { nodeClass = NodeClass.View; } switch (nodeClass) { case NodeClass.Object: { UAObject o = (UAObject)node; BaseObjectState value = new BaseObjectState(null); value.EventNotifier = o.EventNotifier; importedNode = value; break; } case NodeClass.Variable: { UAVariable o = (UAVariable)node; NodeId typeDefinitionId = null; if (node.References != null) { for (int ii = 0; ii < node.References.Length; ii++) { Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true); bool isInverse = !node.References[ii].IsForward; Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris); if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse) { typeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); break; } } } BaseVariableState value = null; if (typeDefinitionId == Opc.Ua.VariableTypeIds.PropertyType) { value = new PropertyState(null); } else { value = new BaseDataVariableState(null); } value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true); value.ValueRank = o.ValueRank; value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions); value.AccessLevelEx = o.AccessLevel; value.UserAccessLevel = (byte)(o.AccessLevel & 0xFF); value.MinimumSamplingInterval = o.MinimumSamplingInterval; value.Historizing = o.Historizing; if (o.Value != null) { XmlDecoder decoder = CreateDecoder(context, o.Value); TypeInfo typeInfo = null; value.Value = decoder.ReadVariantContents(out typeInfo); decoder.Close(); } importedNode = value; break; } case NodeClass.Method: { UAMethod o = (UAMethod)node; MethodState value = new MethodState(null); value.Executable = o.Executable; value.UserExecutable = o.Executable; value.TypeDefinitionId = ImportNodeId(o.MethodDeclarationId, context.NamespaceUris, true); importedNode = value; break; } case NodeClass.View: { UAView o = (UAView)node; ViewState value = new ViewState(); value.ContainsNoLoops = o.ContainsNoLoops; importedNode = value; break; } case NodeClass.ObjectType: { UAObjectType o = (UAObjectType)node; BaseObjectTypeState value = new BaseObjectTypeState(); value.IsAbstract = o.IsAbstract; importedNode = value; break; } case NodeClass.VariableType: { UAVariableType o = (UAVariableType)node; BaseVariableTypeState value = new BaseDataVariableTypeState(); value.IsAbstract = o.IsAbstract; value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true); value.ValueRank = o.ValueRank; value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions); if (o.Value != null) { XmlDecoder decoder = CreateDecoder(context, o.Value); TypeInfo typeInfo = null; value.Value = decoder.ReadVariantContents(out typeInfo); decoder.Close(); } importedNode = value; break; } case NodeClass.DataType: { UADataType o = (UADataType)node; DataTypeState value = new DataTypeState(); value.IsAbstract = o.IsAbstract; Opc.Ua.DataTypeDefinition dataTypeDefinition = Import(o, o.Definition, context.NamespaceUris); value.DataTypeDefinition = new ExtensionObject(dataTypeDefinition); value.Purpose = o.Purpose; value.DataTypeModifier = DataTypeModifier.None; if (o.Definition != null) { if (o.Definition.IsOptionSet) { value.DataTypeModifier = DataTypeModifier.OptionSet; } else if (o.Definition.IsUnion) { value.DataTypeModifier = DataTypeModifier.Union; } } importedNode = value; break; } case NodeClass.ReferenceType: { UAReferenceType o = (UAReferenceType)node; ReferenceTypeState value = new ReferenceTypeState(); value.IsAbstract = o.IsAbstract; value.InverseName = Import(o.InverseName); value.Symmetric = o.Symmetric; importedNode = value; break; } } importedNode.NodeId = ImportNodeId(node.NodeId, context.NamespaceUris, false); importedNode.BrowseName = ImportQualifiedName(node.BrowseName, context.NamespaceUris); importedNode.DisplayName = Import(node.DisplayName); if (importedNode.DisplayName == null) { importedNode.DisplayName = new Ua.LocalizedText(importedNode.BrowseName.Name); } importedNode.Description = Import(node.Description); importedNode.Categories = (node.Category != null && node.Category.Length > 0) ? node.Category : null; importedNode.ReleaseStatus = node.ReleaseStatus; importedNode.WriteMask = (AttributeWriteMask)node.WriteMask; importedNode.UserWriteMask = (AttributeWriteMask)node.UserWriteMask; importedNode.Extensions = node.Extensions; if (!String.IsNullOrEmpty(node.SymbolicName)) { importedNode.SymbolicName = node.SymbolicName; } if (node.References != null) { BaseInstanceState instance = importedNode as BaseInstanceState; BaseTypeState type = importedNode as BaseTypeState; for (int ii = 0; ii < node.References.Length; ii++) { Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true); bool isInverse = !node.References[ii].IsForward; Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris); if (instance != null) { if (referenceTypeId == ReferenceTypeIds.HasModellingRule && !isInverse) { instance.ModellingRuleId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse) { instance.TypeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } } if (type != null) { if (referenceTypeId == ReferenceTypeIds.HasSubtype && isInverse) { type.SuperTypeId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } } importedNode.AddReference(referenceTypeId, isInverse, targetId); } } return(importedNode); }
/// <summary> /// Adds a node to the set. /// </summary> public void Export(ISystemContext context, NodeState node, bool outputRedundantNames = true) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (Opc.Ua.NodeId.IsNull(node.NodeId)) { throw new ArgumentException("A non-null NodeId must be specified."); } UANode exportedNode = null; switch (node.NodeClass) { case NodeClass.Object: { BaseObjectState o = (BaseObjectState)node; UAObject value = new UAObject(); value.EventNotifier = o.EventNotifier; if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } exportedNode = value; break; } case NodeClass.Variable: { BaseVariableState o = (BaseVariableState)node; UAVariable value = new UAVariable(); value.DataType = ExportAlias(o.DataType, context.NamespaceUris); value.ValueRank = o.ValueRank; value.ArrayDimensions = Export(o.ArrayDimensions); value.AccessLevel = o.AccessLevelEx; value.MinimumSamplingInterval = o.MinimumSamplingInterval; value.Historizing = o.Historizing; if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } if (o.Value != null) { XmlEncoder encoder = CreateEncoder(context); Variant variant = new Variant(o.Value); encoder.WriteVariantContents(variant.Value, variant.TypeInfo); XmlDocument document = new XmlDocument(); document.InnerXml = encoder.Close(); value.Value = document.DocumentElement; } exportedNode = value; break; } case NodeClass.Method: { MethodState o = (MethodState)node; UAMethod value = new UAMethod(); value.Executable = o.Executable; if (o.TypeDefinitionId != null && !o.TypeDefinitionId.IsNullNodeId && o.TypeDefinitionId != o.NodeId) { value.MethodDeclarationId = Export(o.TypeDefinitionId, context.NamespaceUris); } if (o.Parent != null) { value.ParentNodeId = ExportAlias(o.Parent.NodeId, context.NamespaceUris); } exportedNode = value; break; } case NodeClass.View: { ViewState o = (ViewState)node; UAView value = new UAView(); value.ContainsNoLoops = o.ContainsNoLoops; exportedNode = value; break; } case NodeClass.ObjectType: { BaseObjectTypeState o = (BaseObjectTypeState)node; UAObjectType value = new UAObjectType(); value.IsAbstract = o.IsAbstract; exportedNode = value; break; } case NodeClass.VariableType: { BaseVariableTypeState o = (BaseVariableTypeState)node; UAVariableType value = new UAVariableType(); value.IsAbstract = o.IsAbstract; value.DataType = ExportAlias(o.DataType, context.NamespaceUris); value.ValueRank = o.ValueRank; value.ArrayDimensions = Export(o.ArrayDimensions); if (o.Value != null) { XmlEncoder encoder = CreateEncoder(context); Variant variant = new Variant(o.Value); encoder.WriteVariantContents(variant.Value, variant.TypeInfo); XmlDocument document = new XmlDocument(); document.InnerXml = encoder.Close(); value.Value = document.DocumentElement; } exportedNode = value; break; } case NodeClass.DataType: { DataTypeState o = (DataTypeState)node; UADataType value = new UADataType(); value.IsAbstract = o.IsAbstract; value.Definition = Export(o, o.DataTypeDefinition, context.NamespaceUris, outputRedundantNames); value.Purpose = o.Purpose; exportedNode = value; break; } case NodeClass.ReferenceType: { ReferenceTypeState o = (ReferenceTypeState)node; UAReferenceType value = new UAReferenceType(); value.IsAbstract = o.IsAbstract; if (!Opc.Ua.LocalizedText.IsNullOrEmpty(o.InverseName)) { value.InverseName = Export(new Opc.Ua.LocalizedText[] { o.InverseName }); } value.Symmetric = o.Symmetric; exportedNode = value; break; } } exportedNode.NodeId = Export(node.NodeId, context.NamespaceUris); exportedNode.BrowseName = Export(node.BrowseName, context.NamespaceUris); if (outputRedundantNames || node.DisplayName.Text != node.BrowseName.Name) { exportedNode.DisplayName = Export(new Opc.Ua.LocalizedText[] { node.DisplayName }); } else { exportedNode.DisplayName = null; } if (node.Description != null && !String.IsNullOrEmpty(node.Description.Text)) { exportedNode.Description = Export(new Opc.Ua.LocalizedText[] { node.Description }); } else { exportedNode.Description = new LocalizedText[0]; } exportedNode.Category = (node.Categories != null && node.Categories.Count > 0) ? new List <string>(node.Categories).ToArray() : null; exportedNode.ReleaseStatus = node.ReleaseStatus; exportedNode.WriteMask = (uint)node.WriteMask; exportedNode.UserWriteMask = (uint)node.UserWriteMask; exportedNode.Extensions = node.Extensions; if (!String.IsNullOrEmpty(node.SymbolicName) && node.SymbolicName != node.BrowseName.Name) { exportedNode.SymbolicName = node.SymbolicName; } // export references. INodeBrowser browser = node.CreateBrowser(context, null, null, true, BrowseDirection.Both, null, null, true); List <Reference> exportedReferences = new List <Reference>(); IReference reference = browser.Next(); while (reference != null) { if (node.NodeClass == NodeClass.Method) { if (!reference.IsInverse && reference.ReferenceTypeId == ReferenceTypeIds.HasTypeDefinition) { reference = browser.Next(); continue; } } Reference exportedReference = new Reference(); exportedReference.ReferenceType = ExportAlias(reference.ReferenceTypeId, context.NamespaceUris); exportedReference.IsForward = !reference.IsInverse; exportedReference.Value = Export(reference.TargetId, context.NamespaceUris, context.ServerUris); exportedReferences.Add(exportedReference); reference = browser.Next(); } exportedNode.References = exportedReferences.ToArray(); // add node to list. UANode[] nodes = null; int count = 1; if (this.Items == null) { nodes = new UANode[count]; } else { count += this.Items.Length; nodes = new UANode[count]; Array.Copy(this.Items, nodes, this.Items.Length); } nodes[count - 1] = exportedNode; this.Items = nodes; // recusively process children. List <BaseInstanceState> children = new List <BaseInstanceState>(); node.GetChildren(context, children); for (int ii = 0; ii < children.Count; ii++) { Export(context, children[ii], outputRedundantNames); } }
/// <summary> /// Convert to stack object /// </summary> /// <param name="nodeModel"></param> /// <param name="context"></param> /// <param name="parent"></param> /// <returns></returns> public static NodeState ToNodeState(this BaseNodeModel nodeModel, ISystemContext context, NodeState parent = null) { NodeState state; switch (nodeModel) { case ViewNodeModel viewState: state = new ViewState { ContainsNoLoops = viewState.ContainsNoLoops ?? false, EventNotifier = viewState.EventNotifier ?? EventNotifiers.None, }; break; case TypeNodeModel typeState: switch (typeState) { case VariableTypeNodeModel variableType: switch (variableType) { case DataVariableTypeNodeModel data: state = new BaseDataVariableTypeState(); break; case PropertyTypeNodeModel property: state = new PropertyTypeState(); break; default: return(null); } var baseVariableTypeState = state as BaseVariableTypeState; baseVariableTypeState.ArrayDimensions = variableType.ArrayDimensions; baseVariableTypeState.DataType = variableType.DataType; baseVariableTypeState.ValueRank = variableType.ValueRank ?? ValueRanks.Scalar; baseVariableTypeState.WrappedValue = variableType.Value ?? Variant.Null; break; case ObjectTypeNodeModel objectType: state = new BaseObjectTypeState(); break; case ReferenceTypeNodeModel referenceType: state = new ReferenceTypeState { Symmetric = referenceType.Symmetric ?? false, InverseName = referenceType.InverseName }; break; case DataTypeNodeModel dataType: state = new DataTypeState { // Definition = dataType.Definition.ToDataTypeDefinition() }; break; default: return(null); } var baseTypeState = state as BaseTypeState; baseTypeState.IsAbstract = typeState.IsAbstract ?? false; break; case InstanceNodeModel instanceState: switch (instanceState) { case VariableNodeModel variable: switch (variable) { case DataVariableNodeModel data: state = new BaseDataVariableState(parent); break; case PropertyNodeModel property: state = new PropertyState(parent); break; default: return(null); } var baseVariableState = state as BaseVariableState; baseVariableState.ArrayDimensions = variable.ArrayDimensions; baseVariableState.DataType = variable.DataType; baseVariableState.ValueRank = variable.ValueRank ?? ValueRanks.Scalar; baseVariableState.Value = variable.Value?.Value; baseVariableState.AccessLevel = variable.AccessLevel ?? AccessLevels.CurrentRead; baseVariableState.UserAccessLevel = variable.UserAccessLevel ?? AccessLevels.CurrentRead; baseVariableState.IsValueType = variable.IsValueType; baseVariableState.Historizing = variable.Historizing ?? false; baseVariableState.MinimumSamplingInterval = variable.MinimumSamplingInterval ?? 0.0; baseVariableState.ModellingRuleId = variable.ModellingRuleId; baseVariableState.NumericId = variable.NumericId; baseVariableState.ReferenceTypeId = variable.ReferenceTypeId; baseVariableState.StatusCode = variable.StatusCode ?? StatusCodes.Good; baseVariableState.Timestamp = variable.Timestamp ?? DateTime.MinValue; baseVariableState.TypeDefinitionId = variable.TypeDefinitionId; break; case ObjectNodeModel obj: state = new BaseObjectState(parent) { EventNotifier = obj.EventNotifier ?? EventNotifiers.None }; break; case MethodNodeModel method: state = new MethodState(parent) { UserExecutable = method.UserExecutable, Executable = method.Executable, MethodDeclarationId = method.MethodDeclarationId }; break; default: return(null); } break; default: return(null); } state.BrowseName = nodeModel.BrowseName; state.Description = nodeModel.Description; state.DisplayName = nodeModel.DisplayName; state.Handle = nodeModel.Handle; state.NodeId = nodeModel.NodeId; state.SymbolicName = nodeModel.SymbolicName; state.WriteMask = nodeModel.WriteMask ?? AttributeWriteMask.None; state.UserWriteMask = nodeModel.UserWriteMask ?? AttributeWriteMask.None; state.Initialized = true; foreach (var child in nodeModel.GetChildren(context)) { state.AddChild(child.ToNodeState(context, state) as BaseInstanceState); } foreach (var reference in nodeModel.References) { state.AddReference(reference.ReferenceTypeId, reference.IsInverse, reference.TargetId); } return(state); }
/// <summary> /// Imports a node from the set. /// </summary> private NodeState Import(ISystemContext context, UANode node) { NodeState importedNode = null; NodeClass nodeClass = NodeClass.Unspecified; if (node is UAObject) nodeClass = NodeClass.Object; else if (node is UAVariable) nodeClass = NodeClass.Variable; else if (node is UAMethod) nodeClass = NodeClass.Method; else if (node is UAObjectType) nodeClass = NodeClass.ObjectType; else if (node is UAVariableType) nodeClass = NodeClass.VariableType; else if (node is UADataType) nodeClass = NodeClass.DataType; else if (node is UAReferenceType) nodeClass = NodeClass.ReferenceType; else if (node is UAView) nodeClass = NodeClass.View; switch (nodeClass) { case NodeClass.Object: { UAObject o = (UAObject)node; BaseObjectState value = new BaseObjectState(null); value.EventNotifier = o.EventNotifier; importedNode = value; break; } case NodeClass.Variable: { UAVariable o = (UAVariable)node; NodeId typeDefinitionId = null; if (node.References != null) { for (int ii = 0; ii < node.References.Length; ii++) { Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true); bool isInverse = !node.References[ii].IsForward; Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris); if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse) { typeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); break; } } } BaseVariableState value = null; if (typeDefinitionId == Opc.Ua.VariableTypeIds.PropertyType) { value = new PropertyState(null); } else { value = new BaseDataVariableState(null); } value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true); value.ValueRank = o.ValueRank; value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions); value.AccessLevel = o.AccessLevel; value.UserAccessLevel = o.UserAccessLevel; value.MinimumSamplingInterval = o.MinimumSamplingInterval; value.Historizing = o.Historizing; if (o.Value != null) { XmlDecoder decoder = CreateDecoder(context, o.Value); TypeInfo typeInfo = null; value.Value = decoder.ReadVariantContents(out typeInfo); decoder.Close(); } importedNode = value; break; } case NodeClass.Method: { UAMethod o = (UAMethod)node; MethodState value = new MethodState(null); value.Executable = o.Executable; value.UserExecutable = o.UserExecutable; importedNode = value; break; } case NodeClass.View: { UAView o = (UAView)node; ViewState value = new ViewState(); value.ContainsNoLoops = o.ContainsNoLoops; importedNode = value; break; } case NodeClass.ObjectType: { UAObjectType o = (UAObjectType)node; BaseObjectTypeState value = new BaseObjectTypeState(); value.IsAbstract = o.IsAbstract; importedNode = value; break; } case NodeClass.VariableType: { UAVariableType o = (UAVariableType)node; BaseVariableTypeState value = new BaseDataVariableTypeState(); value.IsAbstract = o.IsAbstract; value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true); value.ValueRank = o.ValueRank; value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions); if (o.Value != null) { XmlDecoder decoder = CreateDecoder(context, o.Value); TypeInfo typeInfo = null; value.Value = decoder.ReadVariantContents(out typeInfo); decoder.Close(); } importedNode = value; break; } case NodeClass.DataType: { UADataType o = (UADataType)node; DataTypeState value = new DataTypeState(); value.IsAbstract = o.IsAbstract; value.Definition = Import(o.Definition, context.NamespaceUris); importedNode = value; break; } case NodeClass.ReferenceType: { UAReferenceType o = (UAReferenceType)node; ReferenceTypeState value = new ReferenceTypeState(); value.IsAbstract = o.IsAbstract; value.InverseName = Import(o.InverseName); value.Symmetric = o.Symmetric; importedNode = value; break; } } importedNode.NodeId = ImportNodeId(node.NodeId, context.NamespaceUris, false); importedNode.BrowseName = ImportQualifiedName(node.BrowseName, context.NamespaceUris); importedNode.DisplayName = Import(node.DisplayName); importedNode.Description = Import(node.Description); importedNode.WriteMask = (AttributeWriteMask)node.WriteMask; importedNode.UserWriteMask = (AttributeWriteMask)node.UserWriteMask; if (!String.IsNullOrEmpty(node.SymbolicName)) { importedNode.SymbolicName = node.SymbolicName; } if (node.References != null) { BaseInstanceState instance = importedNode as BaseInstanceState; BaseTypeState type = importedNode as BaseTypeState; for (int ii = 0; ii < node.References.Length; ii++) { Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true); bool isInverse = !node.References[ii].IsForward; Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris); if (instance != null) { if (referenceTypeId == ReferenceTypeIds.HasModellingRule && !isInverse) { instance.ModellingRuleId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse) { instance.TypeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } } if (type != null) { if (referenceTypeId == ReferenceTypeIds.HasSubtype && isInverse) { type.SuperTypeId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris); continue; } } importedNode.AddReference(referenceTypeId, isInverse, targetId); } } return importedNode; }
/// <summary> /// Does any initialization required before the address space can be used. /// </summary> /// <remarks> /// The externalReferences is an out parameter that allows the node manager to link to nodes /// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and /// should have a reference to the root folder node(s) exposed by this node manager. /// </remarks> public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences) { lock (Lock) { BaseObjectState trigger = new BaseObjectState(null); trigger.NodeId = new NodeId(1, NamespaceIndex); trigger.BrowseName = new QualifiedName("Trigger", NamespaceIndex); trigger.DisplayName = trigger.BrowseName.Name; trigger.TypeDefinitionId = ObjectTypeIds.BaseObjectType; // ensure trigger can be found via the server object. IList <IReference> references = null; if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } trigger.AddReference(ReferenceTypeIds.Organizes, true, ObjectIds.ObjectsFolder); references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, trigger.NodeId)); //var manager = new TargetsManager(); //var targetDir = manager.GetAllTargets(); //foreach (var item in targetDir) //{ // var targetName = item.Key; // var targetSimpleName = targetName.Substring(targetName.LastIndexOf('.') + 1, targetName.Length - targetName.LastIndexOf('.') - 1); // var dataTypeId = DataTypeHelper.GetDataTypeId(item.Value); // PropertyState property = BuildPropertyState(trigger, targetName, targetSimpleName, dataTypeId, manager); // trigger.AddChild(property); //} // save in dictionary. AddPredefinedNode(SystemContext, trigger); ReferenceTypeState referenceType = new ReferenceTypeState(); referenceType.NodeId = new NodeId(3, NamespaceIndex); referenceType.BrowseName = new QualifiedName("IsTriggerSource", NamespaceIndex); referenceType.DisplayName = referenceType.BrowseName.Name; referenceType.InverseName = new LocalizedText("IsSourceOfTrigger"); referenceType.SuperTypeId = ReferenceTypeIds.NonHierarchicalReferences; if (!externalReferences.TryGetValue(ObjectIds.Server, out references)) { externalReferences[ObjectIds.Server] = references = new List <IReference>(); } trigger.AddReference(referenceType.NodeId, false, ObjectIds.Server); references.Add(new NodeStateReference(referenceType.NodeId, true, trigger.NodeId)); DataSource.NamespaceIndex = NamespaceIndex; DataSource.Trigger = trigger; DataSource.SystemContext = this.SystemContext; //DataSource.StartFlashValue(); // save in dictionary. AddPredefinedNode(SystemContext, referenceType); } }