/// <summary> /// Creates a new data type. /// </summary> private DataTypeState CreateDataType(NodeState parent, IDictionary <NodeId, IList <IReference> > externalReferences, string path, string name) { DataTypeState type = new DataTypeState(); type.SymbolicName = name; type.SuperTypeId = DataTypeIds.Structure; 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; IList <IReference> references = null; if (!externalReferences.TryGetValue(DataTypeIds.Structure, out references)) { externalReferences[DataTypeIds.Structure] = 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); }
//// DataTypes // public DataTypeState CreateAddDataType(string browseDisplayName, NodeId superTypeId, uint preferredNumId = 0) { var x = new DataTypeState(); x.BrowseName = "" + browseDisplayName; x.DisplayName = "" + browseDisplayName; x.Description = new LocalizedText("en", browseDisplayName); x.SuperTypeId = superTypeId; x.NodeId = nodeMgr.NewType(nodeMgr.SystemContext, x, preferredNumId); nodeMgr.AddPredefinedNode(nodeMgr.SystemContext, x); return(x); }
/// <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> /// Exports a DataTypeDefinition /// </summary> private Opc.Ua.Export.DataTypeDefinition Export( DataTypeState dataType, ExtensionObject source, NamespaceTable namespaceUris, bool outputRedundantNames) { if (source == null || source.Body == null) { return(null); } DataTypeDefinition definition = new DataTypeDefinition(); if (outputRedundantNames || dataType.BrowseName != null) { definition.Name = Export(dataType.BrowseName, namespaceUris); } if (dataType.BrowseName.Name != dataType.SymbolicName) { definition.SymbolicName = dataType.SymbolicName; } switch (dataType.DataTypeModifier) { case DataTypeModifier.Union: { definition.IsUnion = true; break; } case DataTypeModifier.OptionSet: { definition.IsOptionSet = true; break; } } StructureDefinition structureDefinition = source.Body as StructureDefinition; if (structureDefinition != null) { if (structureDefinition.StructureType == StructureType.Union) { definition.IsUnion = true; } if (structureDefinition.Fields != null) { List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>(); foreach (StructureField field in structureDefinition.Fields) { Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField(); output.Name = field.Name; output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description }); output.IsOptional = field.IsOptional; if (NodeId.IsNull(field.DataType)) { output.DataType = Export(DataTypeIds.BaseDataType, namespaceUris); } else { output.DataType = Export(field.DataType, namespaceUris); } output.ValueRank = field.ValueRank; fields.Add(output); } definition.Field = fields.ToArray(); } } EnumDefinition enumDefinition = source.Body as EnumDefinition; if (enumDefinition != null) { if (enumDefinition.Fields != null) { List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>(); foreach (EnumField field in enumDefinition.Fields) { Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField(); output.Name = field.Name; output.DisplayName = Export(new Opc.Ua.LocalizedText[] { field.Name }); output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description }); output.ValueRank = ValueRanks.Scalar; output.Value = (int)field.Value; fields.Add(output); } definition.Field = fields.ToArray(); } } return(definition); }
/// <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> /// Exports a DataTypeDefinition /// </summary> private Opc.Ua.Export.DataTypeDefinition Export( DataTypeState dataType, ExtensionObject source, NamespaceTable namespaceUris, bool outputRedundantNames) { if (source == null || source.Body == null) { return(null); } DataTypeDefinition definition = new DataTypeDefinition(); if (outputRedundantNames || dataType.BrowseName != null) { definition.Name = Export(dataType.BrowseName, namespaceUris); } if (dataType.BrowseName.Name != dataType.SymbolicName) { definition.SymbolicName = dataType.SymbolicName; } StructureDefinition sd = source.Body as StructureDefinition; if (sd != null) { if (sd.StructureType == StructureType.Union || sd.StructureType == (StructureType)4) // StructureType.UnionWithSubtypedValues) { definition.IsUnion = true; } if (sd.Fields != null) { List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>(); for (int ii = sd.FirstExplicitFieldIndex; ii < sd.Fields.Count; ii++) { StructureField field = sd.Fields[ii]; Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField(); output.Name = field.Name; output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description }); if (sd.StructureType == StructureType.StructureWithOptionalFields) { output.IsOptional = field.IsOptional; output.AllowSubTypes = false; } else if (sd.StructureType == (StructureType)3 || // StructureType.StructureWithSubtypedValues || sd.StructureType == (StructureType)4) // StructureType.UnionWithSubtypedValues) { output.IsOptional = false; output.AllowSubTypes = field.IsOptional; } else { output.IsOptional = false; output.AllowSubTypes = false; } if (NodeId.IsNull(field.DataType)) { output.DataType = Export(DataTypeIds.BaseDataType, namespaceUris); } else { output.DataType = Export(field.DataType, namespaceUris); } output.ValueRank = field.ValueRank; fields.Add(output); } definition.Field = fields.ToArray(); } } EnumDefinition ed = source.Body as EnumDefinition; if (ed != null) { definition.IsOptionSet = ed.IsOptionSet; if (ed.Fields != null) { List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>(); foreach (EnumField field in ed.Fields) { Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField(); output.Name = field.Name; if (field.DisplayName != null && output.Name != field.DisplayName.Text) { output.DisplayName = Export(new Opc.Ua.LocalizedText[] { field.DisplayName }); } else { output.DisplayName = Array.Empty <LocalizedText>(); } output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description }); output.ValueRank = ValueRanks.Scalar; output.Value = (int)field.Value; fields.Add(output); } definition.Field = fields.ToArray(); } } return(definition); }
/// <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; }
public virtual NodeState BindNodeStates(IDictionary <NodeId, IList <IReference> > externalReferences, NodeState nodeState, ref NodeStateCollection nodeStateCollectionToBind) { switch (nodeState.NodeClass) { case NodeClass.Object: if (!(nodeState is BaseObjectState baseObjectState)) { return(nodeState); } _previousBaseNode = baseObjectState; //Bind previous method now since it will be cleared if (_previousMethod != null) { int index = nodeStateCollectionToBind.FindIndex(x => x.NodeId == _previousMethod.NodeId); if (index == -1) { nodeStateCollectionToBind.Add(_previousMethod); } else { nodeStateCollectionToBind[index] = _previousMethod; } } // ensure the process object can be found via the server object. if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out IList <IReference> references)) { externalReferences[ObjectIds.ObjectsFolder] = references = new List <IReference>(); } references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, _previousBaseNode.NodeId)); _previousMethod = null; break; case NodeClass.DataType: if (!(nodeState is DataTypeState dataTypeState)) { return(nodeState); } BindNodeStateActions(dataTypeState); _previousDataType = dataTypeState; int index2 = nodeStateCollectionToBind.FindIndex(x => x.NodeId == _previousDataType.NodeId); if (index2 == -1) { nodeStateCollectionToBind.Add(_previousDataType); } else { nodeStateCollectionToBind[index2] = _previousDataType; } break; case NodeClass.Method: if (!(nodeState is MethodState methodState)) { return(nodeState); } BindNodeStateActions(methodState); _previousBaseNode?.AddChild(methodState); if (_previousMethod != null) { int index = nodeStateCollectionToBind.FindIndex(x => x.NodeId == _previousMethod.NodeId); if (index == -1) { nodeStateCollectionToBind.Add(_previousMethod); } else { nodeStateCollectionToBind[index] = _previousMethod; } } _previousMethod = methodState; return(methodState); case NodeClass.Variable: if (_previousMethod != null) { if (!(nodeState is PropertyState propertyState)) { return(nodeState); } BindNodeStateActions(propertyState); if (propertyState.DisplayName == BrowseNames.InputArguments) { _previousMethod.InputArguments = new PropertyState <Argument[]>(_previousMethod) { NodeId = propertyState.NodeId, BrowseName = propertyState.BrowseName, DisplayName = propertyState.DisplayName, TypeDefinitionId = propertyState.TypeDefinitionId, ReferenceTypeId = propertyState.ReferenceTypeId, DataType = propertyState.DataType, ValueRank = propertyState.ValueRank, Value = ExtensionObject.ToArray(propertyState.Value, typeof(Argument)) as Argument[], OnReadUserAccessLevel = OnReadUserAccessLevel, OnSimpleWriteValue = OnWriteValue }; } else if (propertyState.DisplayName == BrowseNames.OutputArguments) { _previousMethod.OutputArguments = new PropertyState <Argument[]>(_previousMethod) { NodeId = propertyState.NodeId, BrowseName = propertyState.BrowseName, DisplayName = propertyState.DisplayName, TypeDefinitionId = propertyState.TypeDefinitionId, ReferenceTypeId = propertyState.ReferenceTypeId, DataType = propertyState.DataType, ValueRank = propertyState.ValueRank, Value = ExtensionObject.ToArray(propertyState.Value, typeof(Argument)) as Argument[], OnReadUserAccessLevel = OnReadUserAccessLevel, OnSimpleWriteValue = OnWriteValue }; } } break; default: if (_previousBaseNode != null) { int index = nodeStateCollectionToBind.FindIndex(x => x.NodeId == _previousBaseNode.NodeId); if (index == -1) { nodeStateCollectionToBind.Add(_previousBaseNode); } else { nodeStateCollectionToBind[index] = _previousBaseNode; } } if (_previousMethod != null) { int index = nodeStateCollectionToBind.FindIndex(x => x.NodeId == _previousMethod.NodeId); if (index == -1) { nodeStateCollectionToBind.Add(_previousMethod); } else { nodeStateCollectionToBind[index] = _previousMethod; } } _previousBaseNode = null; _previousMethod = null; break; } return(nodeState); }
/// <summary> /// Exports a DataTypeDefinition /// </summary> private Opc.Ua.Export.DataTypeDefinition Export( DataTypeState dataType, Opc.Ua.DataTypeDefinition2 source, NamespaceTable namespaceUris, bool outputRedundantNames) { if (source == null) { return(null); } DataTypeDefinition definition = new DataTypeDefinition(); if (outputRedundantNames || dataType.BrowseName != source.Name) { definition.Name = Export(source.Name, namespaceUris); } if (source.Name.Name != source.SymbolicName) { definition.SymbolicName = source.SymbolicName; } switch (source.DataTypeModifier) { case DataTypeModifier.Union: { definition.IsUnion = true; break; } case DataTypeModifier.OptionSet: { definition.IsOptionSet = true; break; } } if (source.Fields != null) { List <Opc.Ua.Export.DataTypeField> fields = new List <DataTypeField>(); foreach (DataTypeDefinitionField field in source.Fields) { Opc.Ua.Export.DataTypeField output = new Opc.Ua.Export.DataTypeField(); output.Name = field.Name; output.SymbolicName = field.SymbolicName; output.Description = Export(new Opc.Ua.LocalizedText[] { field.Description }); if (NodeId.IsNull(field.DataType)) { output.DataType = Export(DataTypeIds.BaseDataType, namespaceUris); } else { output.DataType = Export(field.DataType, namespaceUris); } output.ValueRank = field.ValueRank; output.Value = field.Value; fields.Add(output); } definition.Field = fields.ToArray(); } return(definition); }