/// <summary> /// Imports a ExpandedNodeId /// </summary> private Opc.Ua.ExpandedNodeId ImportExpandedNodeId(string source, NamespaceTable namespaceUris, StringTable serverUris) { if (String.IsNullOrEmpty(source)) { return(Opc.Ua.ExpandedNodeId.Null); } // parse the node. Opc.Ua.ExpandedNodeId nodeId = Opc.Ua.ExpandedNodeId.Parse(source); if (nodeId.ServerIndex <= 0 && nodeId.NamespaceIndex <= 0 && String.IsNullOrEmpty(nodeId.NamespaceUri)) { return(nodeId); } uint serverIndex = ImportServerIndex(nodeId.ServerIndex, serverUris); ushort namespaceIndex = ImportNamespaceIndex(nodeId.NamespaceIndex, namespaceUris); if (serverIndex > 0) { string namespaceUri = nodeId.NamespaceUri; if (String.IsNullOrEmpty(nodeId.NamespaceUri)) { namespaceUri = namespaceUris.GetString(namespaceIndex); } nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, 0, namespaceUri, serverIndex); return(nodeId); } nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, namespaceIndex, null, 0); return(nodeId); }
/// <summary cref="ITypeTable.FindSuperType(ExpandedNodeId)" /> public NodeId FindSuperType(ExpandedNodeId typeId) { if (NodeId.IsNull(typeId) || typeId.ServerIndex != 0) { return NodeId.Null; } NodeId localId = ExpandedNodeId.ToNodeId(typeId, m_namespaceUris); if (localId == null) { return NodeId.Null; } lock (m_lock) { TypeInfo typeInfo = null; if (!m_nodes.TryGetValue(localId, out typeInfo)) { return NodeId.Null; } if (typeInfo.SuperType != null) { return typeInfo.SuperType.NodeId; } return NodeId.Null; } }
/// <summary> /// Initializes the node id with an identifier. /// </summary> public NodeId(ExpandedNodeId nodeId) { if (!NodeId.IsNull(nodeId)) { Identifier = nodeId.Identifier; } }
/// <summary> /// Displays the dialog. /// </summary> public ExpandedNodeId ShowDialog(Session session, ExpandedNodeId value) { if (session == null) throw new ArgumentNullException("session"); m_browser = new Browser(session); m_rootId = Objects.RootFolder; Identifier = ExpandedNodeId.ToNodeId(value, session.NamespaceUris); Popup myPopup = new Popup(); myPopup.Child = this; myPopup.IsOpen = true; return this.Identifier; }
/// <summary cref="ITypeTable.IsKnown(ExpandedNodeId)" /> public bool IsKnown(ExpandedNodeId typeId) { if (NodeId.IsNull(typeId) || typeId.ServerIndex != 0) { return false; } NodeId localId = ExpandedNodeId.ToNodeId(typeId, m_namespaceUris); if (localId == null) { return false; } lock (m_lock) { return m_nodes.ContainsKey(localId); } }
/// <summary> /// Serializes the value using XML and stores it in the extension object. /// </summary> public ExtensionObject(ExpandedNodeId typeId, object value) { TypeId = typeId; StringBuilder buffer = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(buffer)) { DataContractSerializer serializer = new DataContractSerializer(value.GetType()); serializer.WriteObject(writer, value); } XmlDocument document = new XmlDocument(); document.InnerXml = buffer.ToString(); ExtensionObjectBody body = new ExtensionObjectBody(); body.Nodes = new XmlNode[] { document.DocumentElement }; Body = body; }
/// <summary> /// Constructs a reference to an external target. /// </summary> public NodeStateReference(NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { m_referenceTypeId = referenceTypeId; m_isInverse = isInverse; m_targetId = targetId; m_target = null; }
/// <summary> /// Imports a ExpandedNodeId /// </summary> private Opc.Ua.ExpandedNodeId ImportExpandedNodeId(string source, NamespaceTable namespaceUris, StringTable serverUris) { if (String.IsNullOrEmpty(source)) { return Opc.Ua.ExpandedNodeId.Null; } // parse the node. Opc.Ua.ExpandedNodeId nodeId = Opc.Ua.ExpandedNodeId.Parse(source); if (nodeId.ServerIndex <= 0 && nodeId.NamespaceIndex <= 0 && String.IsNullOrEmpty(nodeId.NamespaceUri)) { return nodeId; } uint serverIndex = ImportServerIndex(nodeId.ServerIndex, serverUris); ushort namespaceIndex = ImportNamespaceIndex(nodeId.NamespaceIndex, namespaceUris); if (serverIndex > 0) { string namespaceUri = nodeId.NamespaceUri; if (String.IsNullOrEmpty(nodeId.NamespaceUri)) { namespaceUri = namespaceUris.GetString(namespaceIndex); } nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, 0, namespaceUri, serverIndex); return nodeId; } nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, namespaceIndex, null, 0); return nodeId; }
/// <summary> /// Initializes the reference. /// </summary> /// <param name="referenceTypeId">The reference type id.</param> /// <param name="isInverse">if set to <c>true</c> [is inverse].</param> /// <param name="targetId">The target id.</param> public ReferenceNode(NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { m_referenceTypeId = referenceTypeId; m_isInverse = isInverse; m_targetId = targetId; }
/// <summary> /// Creates an operand that references a component/property of a type. /// </summary> public SimpleAttributeOperand( FilterContext context, ExpandedNodeId typeDefinitionId, string browsePath, uint attributeId, string indexRange) { m_typeDefinitionId = ExpandedNodeId.ToNodeId(typeDefinitionId, context.NamespaceUris); m_browsePath = Parse(browsePath); m_attributeId = attributeId; m_indexRange = indexRange; }
/// <summary> /// Recursively collects the nodes within a type hierarchy. /// </summary> private void GetInstanceHierarchyForType( HierarchyBrowsePath parent, ExpandedNodeId instanceId, InstanceDeclarationHierarchy hierarchy) { // the instance must be local to the address space. ILocalNode instance = m_nodes.Find(instanceId) as ILocalNode; if (instance == null) { return; } // must be an object, variable or method. if ((instance.NodeClass & (NodeClass.Object | NodeClass.Variable | NodeClass.Method)) == 0) { return; } // get the naming rule. NamingRule namingRule = GetNamingRule(instance.ModellingRule); // only include instances with unique browse names in the hierarchy. if (namingRule != NamingRule.Unique && namingRule != NamingRule.UniqueOptional) { return; } // construct the browse path that identifies the node. string browsePath = null; if (parent.BrowsePath == "/") { browsePath = Utils.Format("/{0}", instance.BrowseName); } else { browsePath = Utils.Format("{0}/{1}", parent.BrowsePath, instance.BrowseName); } // check if the browse path already exists in the hierarchy. HierarchyBrowsePath child = null; if (!hierarchy.BrowsePaths.TryGetValue(browsePath, out child)) { child = new HierarchyBrowsePath(); child.BrowsePath = browsePath; child.DeclarationId = instance.NodeId; child.InstanceId = null; child.IsModelParent = false; child.IsOptional = namingRule != NamingRule.Unique; // add new browse path to hierarchy. hierarchy.BrowsePaths.Add(browsePath, child); } // override any declaration specified in a supertype. child.DeclarationId = instance.NodeId; // check if node has been processed via another path. HierarchyBrowsePath alternatePath = null; if (hierarchy.Declarations.TryGetValue(instance.NodeId, out alternatePath)) { // keep the model parent path as the primary path. if (!alternatePath.IsModelParent && child.IsModelParent) { hierarchy.Declarations[instance.NodeId] = child; } // nothing more to do since node has been processed once. return; } // save child. hierarchy.Declarations.Add(instance.NodeId, child); // follow children. foreach (IReference reference in instance.References.Find(ReferenceTypeIds.HierarchicalReferences, false, true, m_nodes.TypeTree)) { GetInstanceHierarchyForType(child, reference.TargetId, hierarchy); } }
/// <summary> /// Recursively builds the full inhierited type hierarchy starting with the top-level type. /// </summary> private void GetInstanceHierarchyForType(ExpandedNodeId typeId, InstanceDeclarationHierarchy hierarchy) { // the type must be local to the address space. ILocalNode type = m_nodes.Find(typeId) as ILocalNode; if (type == null) { throw ServiceResultException.Create( StatusCodes.BadNodeIdUnknown, "The type is not in the local address space.\r\nNodeId = {0}", typeId); } // must be an object or variable type. if ((type.NodeClass & (NodeClass.ObjectType | NodeClass.VariableType)) == 0) { throw ServiceResultException.Create( StatusCodes.BadNodeClassInvalid, "The type node is not an ObjectType or VariableType.\r\nNodeId = {0}\r\nNodeClass = {1}", typeId, type.NodeClass); } // find hierarchy in supertypes first. foreach (IReference reference in type.References.Find(ReferenceTypeIds.HasSubtype, true, false, null)) { GetInstanceHierarchyForType(reference.TargetId, hierarchy); } string browsePath = "/"; // check if the browse path already exists in the hierarchy. HierarchyBrowsePath parent = null; if (!hierarchy.BrowsePaths.TryGetValue(browsePath, out parent)) { parent = new HierarchyBrowsePath(); parent.BrowsePath = browsePath; parent.DeclarationId = type.NodeId; parent.InstanceId = null; parent.IsModelParent = true; parent.IsOptional = false; // add new browse path to hierarchy. hierarchy.BrowsePaths.Add(browsePath, parent); } // override any declaration specified in a supertype. parent.DeclarationId = type.NodeId; hierarchy.Declarations[type.NodeId] = parent; // follow hierarchial references to nodes with a naming rule of unique or unique optional. foreach (IReference reference in type.References.Find(ReferenceTypeIds.HierarchicalReferences, false, true, m_nodes.TypeTree)) { GetInstanceHierarchyForType(parent, reference.TargetId, hierarchy); } // update references defined in the type. foreach (HierarchyBrowsePath declaration in hierarchy.Declarations.Values) { // the declaration must be local to the address space. ILocalNode declarationNode = m_nodes.Find(declaration.DeclarationId) as ILocalNode; if (declarationNode == null) { continue; } // process all references. foreach (IReference reference in declarationNode.References) { UpdateReferenceDeclaration(declaration, reference, hierarchy); } } }
/// <summary> /// Creates an operand that references a component/property of a type. /// </summary> /// <param name="context">The context.</param> /// <param name="typeDefinitionId">The type definition identifier.</param> /// <param name="browsePath">The browse path.</param> /// <param name="attributeId">The attribute identifier.</param> /// <param name="indexRange">The index range.</param> public AttributeOperand( FilterContext context, ExpandedNodeId typeDefinitionId, string browsePath, uint attributeId, string indexRange) { m_nodeId = ExpandedNodeId.ToNodeId(typeDefinitionId, context.NamespaceUris); m_browsePath = RelativePath.Parse(browsePath, context.TypeTree); m_attributeId = attributeId; m_indexRange = indexRange; m_alias = null; }
/// <summary> /// Initializes the object with a <paramref name="typeId"/>. /// </summary> /// <param name="typeId">The type to copy and create an instance from</param> public ExtensionObject(ExpandedNodeId typeId) { TypeId = typeId; Body = null; }
/// <summary> /// Updates the nodeset string tables and returns a NodeId that references those tables. /// </summary> /// <param name="nodeId">The node identifier.</param> /// <param name="targetNamespaceUris">The target namespace URIs.</param> /// <param name="targetServerUris">The target server URIs.</param> /// <param name="sourceNamespaceUris">The source namespace URIs.</param> /// <param name="sourceServerUris">The source server URIs.</param> /// <returns>A NodeId that references those tables.</returns> private static ExpandedNodeId Translate( ExpandedNodeId nodeId, NamespaceTable targetNamespaceUris, StringTable targetServerUris, NamespaceTable sourceNamespaceUris, StringTable sourceServerUris) { if (targetNamespaceUris == null) { throw new ArgumentNullException("targetNamespaceUris"); } if (sourceNamespaceUris == null) { throw new ArgumentNullException("sourceNamespaceUris"); } if (nodeId.ServerIndex > 0) { if (targetServerUris == null) { throw new ArgumentNullException("targetServerUris"); } if (sourceServerUris == null) { throw new ArgumentNullException("sourceServerUris"); } } if (NodeId.IsNull(nodeId)) { return(nodeId); } if (!nodeId.IsAbsolute) { return(Translate((NodeId)nodeId, targetNamespaceUris, sourceNamespaceUris)); } string namespaceUri = nodeId.NamespaceUri; if (nodeId.ServerIndex > 0) { if (String.IsNullOrEmpty(namespaceUri)) { namespaceUri = sourceNamespaceUris.GetString(nodeId.NamespaceIndex); } string serverUri = sourceServerUris.GetString(nodeId.ServerIndex); int index = targetServerUris.GetIndex(serverUri); if (index == -1) { index = targetServerUris.Append(serverUri); } return(new ExpandedNodeId(new NodeId(nodeId.Identifier, 0), namespaceUri, (uint)index)); } ushort namespaceIndex = 0; if (!String.IsNullOrEmpty(namespaceUri)) { int index = targetNamespaceUris.GetIndex(namespaceUri); if (index == -1) { index = targetNamespaceUris.Append(namespaceUri); } namespaceIndex = (ushort)index; } return(new NodeId(nodeId.Identifier, namespaceIndex)); }
/// <summary> /// Updates the specified string tables and returns a NodeId that references those tables. /// </summary> /// <param name="nodeId">The node identifier.</param> /// <param name="namespaceUris">The namespace URIs.</param> /// <param name="serverUris">The server URIs.</param> /// <returns>A NodeId that references those tables.</returns> public ExpandedNodeId Import(ExpandedNodeId nodeId, NamespaceTable namespaceUris, StringTable serverUris) { return(Translate(nodeId, namespaceUris, serverUris, m_namespaceUris, m_serverUris)); }
/// <summary> /// Adds a node to the type table if it is a type and does not already exist. If it exists references are updated. /// </summary> /// <param name="node">The node.</param> public void Add(ILocalNode node) { // ignore null. if (node == null || NodeId.IsNull(node.NodeId)) { return; } // ignore non-types. if ((node.NodeClass & (NodeClass.ObjectType | NodeClass.VariableType | NodeClass.ReferenceType | NodeClass.DataType)) == 0) { return; } NodeId localsuperTypeId = null; // find the supertype. ExpandedNodeId superTypeId = node.References.FindTarget(ReferenceTypeIds.HasSubtype, true, false, null, 0); if (superTypeId != null) { localsuperTypeId = ExpandedNodeId.ToNodeId(superTypeId, m_namespaceUris); if (localsuperTypeId == null) { throw ServiceResultException.Create(StatusCodes.BadNodeIdInvalid, "A valid supertype identifier is required."); } } lock (m_lock) { // lookup the supertype. TypeInfo superTypeInfo = null; if (localsuperTypeId != null) { if (!m_nodes.TryGetValue(localsuperTypeId, out superTypeInfo)) { throw ServiceResultException.Create(StatusCodes.BadNodeIdInvalid, "A valid supertype identifier is required."); } } // create the type info. TypeInfo typeInfo = null; if (!m_nodes.TryGetValue(node.NodeId, out typeInfo)) { typeInfo = new TypeInfo(); m_nodes.Add(node.NodeId, typeInfo); } // update the info. typeInfo.NodeId = node.NodeId; typeInfo.SuperType = superTypeInfo; typeInfo.Deleted = false; // add to supertype. if (superTypeInfo != null) { superTypeInfo.AddSubType(typeInfo); } // remove the encodings. if (typeInfo.Encodings != null) { foreach (NodeId encoding in typeInfo.Encodings) { m_encodings.Remove(encoding); } } // any new encodings. IList <IReference> encodings = node.References.Find(ReferenceTypeIds.HasEncoding, false, false, null); if (encodings.Count > 0) { typeInfo.Encodings = new NodeId[encodings.Count]; for (int ii = 0; ii < encodings.Count; ii++) { typeInfo.Encodings[ii] = ExpandedNodeId.ToNodeId(encodings[ii].TargetId, m_namespaceUris); m_encodings[typeInfo.Encodings[ii]] = typeInfo; } } // add reference type. if ((node.NodeClass & NodeClass.ReferenceType) != 0) { if (!QualifiedName.IsNull(typeInfo.BrowseName)) { m_referenceTypes.Remove(typeInfo.BrowseName); } typeInfo.BrowseName = node.BrowseName; m_referenceTypes[node.BrowseName] = typeInfo; } } }
/// <summary> /// Adds a set of nodes to the table. /// </summary> /// <param name="nodeSet">The node set.</param> /// <param name="externalReferences">The external references.</param> /// <returns></returns> public List <Node> Import(NodeSet nodeSet, IDictionary <NodeId, IList <IReference> > externalReferences) { List <Node> importedNodes = new List <Node>(); if (nodeSet == null) { return(importedNodes); } // add the nodes. foreach (Node nodeToImport in nodeSet.Nodes) { // ignore empty nodes. if (nodeToImport == null || NodeId.IsNull(nodeToImport.NodeId)) { continue; } Node node = nodeSet.Copy(nodeToImport, m_namespaceUris, m_serverUris); // assign a browse name. if (QualifiedName.IsNull(node.BrowseName)) { node.BrowseName = new QualifiedName(node.NodeId.ToString(), 1); } // assign a display name. if (LocalizedText.IsNullOrEmpty(node.DisplayName)) { node.DisplayName = new LocalizedText(node.BrowseName.Name); } // index references (the node ids in the references were translated by the Copy() call above). foreach (ReferenceNode reference in node.References) { // ignore invalid references. if (NodeId.IsNull(reference.ReferenceTypeId) || NodeId.IsNull(reference.TargetId)) { continue; } // ignore missing targets. ExpandedNodeId targetId = reference.TargetId; if (NodeId.IsNull(targetId)) { continue; } // index reference. node.ReferenceTable.Add(reference.ReferenceTypeId, reference.IsInverse, targetId); // see if a remote node needs to be created. if (targetId.ServerIndex != 0) { RemoteNode remoteNode = Find(targetId) as RemoteNode; if (remoteNode == null) { remoteNode = new RemoteNode(this, targetId); InternalAdd(remoteNode); } remoteNode.AddRef(); } } // clear imported references. node.References.Clear(); // add the node. InternalAdd(node); importedNodes.Add(node); } // import the nodes. foreach (Node node in importedNodes) { // ignore invalid nodes. if (node == null || NodeId.IsNull(node.NodeId)) { continue; } // add reverse references. foreach (IReference reference in node.ReferenceTable) { Node targetNode = Find(reference.TargetId) as Node; if (targetNode == null) { if (reference.TargetId.ServerIndex != 0) { continue; } // return the reverse reference to a node outside the table. if (externalReferences != null) { NodeId targetId = ExpandedNodeId.ToNodeId(reference.TargetId, m_namespaceUris); if (targetId == null) { continue; } IList <IReference> referenceList = null; if (!externalReferences.TryGetValue(targetId, out referenceList)) { externalReferences[targetId] = referenceList = new List <IReference>(); } ReferenceNode reverseReference = new ReferenceNode(); reverseReference.ReferenceTypeId = reference.ReferenceTypeId; reverseReference.IsInverse = !reference.IsInverse; reverseReference.TargetId = node.NodeId; referenceList.Add(reverseReference); } continue; } // type definition and modelling rule references are one way. if (reference.ReferenceTypeId != ReferenceTypeIds.HasTypeDefinition && reference.ReferenceTypeId != ReferenceTypeIds.HasModellingRule) { targetNode.ReferenceTable.Add(reference.ReferenceTypeId, !reference.IsInverse, node.NodeId); } } // see if it is a type. if (m_typeTree != null) { m_typeTree.Add(node); } } return(importedNodes); }
/// <summary> /// Returns a list of references to the specified target. /// </summary> /// <param name="targetId">The target identifier.</param> /// <returns>A list of references to the specified target.</returns> public IList <IReference> FindReferencesToTarget(ExpandedNodeId targetId) { return(m_references.FindReferencesToTarget(targetId)); }
/// <summary> /// Checks if the node id is null. /// </summary> public static bool IsNull(ExpandedNodeId nodeId) { if (nodeId == null || String.IsNullOrEmpty(nodeId.Identifier)) { return true; } return false; }
/// <summary> /// Removes the reference from the node. /// </summary> /// <param name="referenceTypeId">The reference type identifier.</param> /// <param name="isInverse">if set to <c>true</c> this is inverse reference.</param> /// <param name="targetId">The target identifier.</param> /// <returns>The result of removal.</returns> public bool Remove(NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { return(m_references.Remove(new ReferenceNode(referenceTypeId, isInverse, targetId))); }
/// <summary> /// Initializes the object with an encodeable object. /// </summary> /// <param name="typeId">The type describing the body</param> /// <param name="body">The underlying data/body to wrap</param> /// <remarks> /// Initializes the object with an encodeable object. /// </remarks> public ExtensionObject(ExpandedNodeId typeId, object body) { TypeId = typeId; Body = body; }
/// <summary> /// Converts a value to a ExpandedNodeId /// </summary> private static object ToExpandedNodeId(object value, BuiltInType sourceType) { // check for array conversions. Array array = value as Array; if (array != null) { ExpandedNodeId[] output = new ExpandedNodeId[array.Length]; for (int ii = 0; ii < array.Length; ii++) { output[ii] = (ExpandedNodeId)Cast(array.GetValue(ii), BuiltInType.ExpandedNodeId); } return output; } // handle for supported conversions. switch (sourceType) { case BuiltInType.ExpandedNodeId: { return (ExpandedNodeId)value; } case BuiltInType.NodeId: { return (ExpandedNodeId)(NodeId)value; } case BuiltInType.String: { return ExpandedNodeId.Parse((string)value); } } // conversion not supported. return null; }
/// <summary> /// Returns true if the node is in the table. /// </summary> /// <param name="nodeId">The node identifier.</param> /// <returns></returns> public bool Exists(ExpandedNodeId nodeId) { return(InternalFind(nodeId) != null); }
/// <summary> /// Removes a subtype. /// </summary> /// <param name="typeId">The type identifier.</param> public void Remove(ExpandedNodeId typeId) { if (NodeId.IsNull(typeId) || typeId.ServerIndex != 0) { return; } NodeId localId = ExpandedNodeId.ToNodeId(typeId, m_namespaceUris); if (localId == null) { return; } lock (m_lock) { // remove type. TypeInfo typeInfo = null; if (!m_nodes.TryGetValue(localId, out typeInfo)) { return; } m_nodes.Remove(localId); // setting the flag to deleted ensures references from subtypes are not broken. typeInfo.Deleted = true; // remove from subtype list. if (typeInfo.SuperType != null) { typeInfo.SuperType.RemoveSubType(localId); } // remove encodings. if (typeInfo.Encodings != null) { for (int ii = 0; ii < typeInfo.Encodings.Length; ii++) { m_encodings.Remove(typeInfo.Encodings[ii]); } } // remove reference type. if (!QualifiedName.IsNull(typeInfo.BrowseName)) { m_referenceTypes.Remove(typeInfo.BrowseName); } } }
/// <summary> /// Finds a node in the node set. /// </summary> /// <param name="nodeId">The node identifier.</param> /// <returns>Returns null if the node does not exist.</returns> public INode Find(ExpandedNodeId nodeId) { return(InternalFind(nodeId)); }
/// <summary> /// Creates an operand that references a component/property of a type. /// </summary> public SimpleAttributeOperand( FilterContext context, ExpandedNodeId typeId, IList<QualifiedName> browsePath) { m_typeDefinitionId = ExpandedNodeId.ToNodeId(typeId, context.NamespaceUris); m_browsePath = new QualifiedNameCollection(browsePath); m_attributeId = Attributes.Value; m_indexRange = null; }
/// <summary> /// Compares the current instance to the object. /// </summary> /// <remarks> /// Compares the current instance to the object. /// </remarks> public int CompareTo(object obj) { // check for null. if (Object.ReferenceEquals(obj, null)) { return(-1); } // check for reference comparisons. if (Object.ReferenceEquals(this, obj)) { return(0); } // just compare node ids. if (!this.IsAbsolute) { if (this.m_nodeId != null) { return(this.m_nodeId.CompareTo(obj)); } } NodeId nodeId = obj as NodeId; // check for expanded node ids. ExpandedNodeId expandedId = obj as ExpandedNodeId; if (expandedId != null) { if (this.IsNull && expandedId.IsNull) { return(0); } if (this.ServerIndex != expandedId.ServerIndex) { return(this.ServerIndex.CompareTo(expandedId.ServerIndex)); } if (this.NamespaceUri != expandedId.NamespaceUri) { if (this.NamespaceUri != null) { return(String.CompareOrdinal(NamespaceUri, expandedId.NamespaceUri)); } return(-1); } nodeId = expandedId.m_nodeId; } // check for null. if (this.m_nodeId != null) { return(this.m_nodeId.CompareTo(nodeId)); } // compare node ids. return((nodeId == null) ? 0 : -1); }
/// <summary> /// Returns true if the reference exist. /// </summary> /// <param name="referenceTypeId">The reference type id.</param> /// <param name="isInverse">if set to <c>true</c> [is inverse].</param> /// <param name="targetId">The target id.</param> /// <returns>True if the reference exist.</returns> public bool ReferenceExists( NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { return ReferenceTable.Exists(referenceTypeId, isInverse, targetId, false, null); }
public bool WriteUDT(List <string> opcNodes, List <object> values, out List <bool> status) { bool ret = false; try { if (opcNodes.Count != values.Count) { throw new Exception("opcNodes.Count != values.Count"); } int count = opcNodes.Count; status = new List <bool>(count); List <Type> types = new List <Type>(count); List <NodeId> nodeIds = new List <NodeId>(count); DiagnosticInfoCollection diags; StatusCodeCollection statusCodes; WriteValueCollection writeValues = new WriteValueCollection(count); for (int i = 0; i < count; i++) { //Variant variant = new Variant(values[i]); Opc.Ua.ExpandedNodeId expNodeId = new Opc.Ua.ExpandedNodeId(opcNodes[i]); Opc.Ua.ExtensionObject extObj = new Opc.Ua.ExtensionObject(expNodeId, values[i]); DataValue dataVal = new DataValue(extObj); WriteValue writeVal = new WriteValue(); //writeVal. writeVal.Value = dataVal; writeVal.NodeId = new NodeId(opcNodes[i]); writeVal.AttributeId = Attributes.Value; writeValues.Add(writeVal); } ResponseHeader rh = session.Write(null, writeValues, out statusCodes, out diags); ret = StatusCode.IsGood(rh.ServiceResult.Code); for (int i = 0; i < count; i++) { //status[i] = StatusCode.IsGood(statusCodes[i]); status.Add(StatusCode.IsGood(statusCodes[i])); ret = ret & status[i]; } } catch (Exception ex) { ret = false; status = null; System.Diagnostics.Debug.WriteLine("Exception OpcUaClient::WriteValues " + ex.Message); } return(ret); }
/// <summary> /// Writes an ExpandedNodeId to the stream. /// </summary> public void WriteExpandedNodeId(string fieldName, ExpandedNodeId value) { if (NodeId.IsNull(value)) { WriteSimpleField(fieldName, null, false); return; } PushStructure(fieldName); if (UseReversibleEncoding) { WriteSimpleField("Id", new NodeId(value.Identifier, value.NamespaceIndex).ToString(), true); if (!String.IsNullOrEmpty(value.NamespaceUri)) { WriteSimpleField("Uri", value.NamespaceUri, true); } if (value.ServerIndex > 0) { WriteSimpleField("ServerIndex", value.ServerIndex.ToString(), false); } } else { WriteSimpleField("Id", new NodeId(value.Identifier, 0).ToString(), true); WriteNamespaceIndex(value.NamespaceIndex); WriteServerIndex(value.ServerIndex); } PopStructure(); }
private ServiceResult OnUserScalarValue2( ISystemContext context, MethodState method, NodeId objectId, DateTime dateTimeIn, Uuid guidIn, byte[] byteStringIn, XmlElement xmlElementIn, NodeId nodeIdIn, ExpandedNodeId expandedNodeIdIn, QualifiedName qualifiedNameIn, LocalizedText localizedTextIn, StatusCode statusCodeIn, object variantIn, ref DateTime dateTimeOut, ref Uuid guidOut, ref byte[] byteStringOut, ref XmlElement xmlElementOut, ref NodeId nodeIdOut, ref ExpandedNodeId expandedNodeIdOut, ref QualifiedName qualifiedNameOut, ref LocalizedText localizedTextOut, ref StatusCode statusCodeOut, ref object variantOut) { dateTimeOut = dateTimeIn; guidOut = guidIn; byteStringOut = byteStringIn; xmlElementOut = xmlElementIn; nodeIdOut = nodeIdIn; expandedNodeIdOut = expandedNodeIdIn; qualifiedNameOut = qualifiedNameIn; localizedTextOut = localizedTextIn; statusCodeOut = statusCodeIn; variantOut = variantIn; return ServiceResult.Good; }
/// <summary> /// Adds a reference to target identified by its node id. /// </summary> public virtual void Add(NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { lock (DataLock) { m_references.Add(new NodeStateReference(referenceTypeId, isInverse, targetId)); } }
/// <summary> /// This method is used to delete bi-directional references to nodes from other node managers. /// </summary> public virtual ServiceResult DeleteReference( object sourceHandle, NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId, bool deleteBiDirectional) { lock (Lock) { // get the handle. NodeHandle source = IsHandleInNamespace(sourceHandle); if (source == null) { return StatusCodes.BadNodeIdUnknown; } // only support external references to nodes that are stored in memory. if (!source.Validated || source.Node == null) { return StatusCodes.BadNotSupported; } // only support references to Source Areas. source.Node.RemoveReference(referenceTypeId, isInverse, targetId); if (deleteBiDirectional) { // check if the target is also managed by this node manager. if (!targetId.IsAbsolute) { NodeHandle target = GetManagerHandle(m_systemContext, (NodeId)targetId, null); if (target != null && target.Validated && target.Node != null) { target.Node.RemoveReference(referenceTypeId, !isInverse, source.NodeId); } } } return ServiceResult.Good; } }
/// <summary> /// Reads the body extension object from the stream. /// </summary> public object ReadExtensionObjectBody(ExpandedNodeId typeId) { m_reader.MoveToContent(); // check for binary encoded body. if (m_reader.LocalName == "ByteString" && m_reader.NamespaceURI == Namespaces.OpcUaXsd) { PushNamespace(Namespaces.OpcUaXsd); byte[] bytes = ReadByteString("ByteString"); PopNamespace(); return bytes; } // check for empty body. XmlDocument document = new XmlDocument(); if (m_reader.IsEmptyElement) { document.InnerXml = m_reader.ReadOuterXml(); return document.DocumentElement; } // lookup type. IEncodeable encodeable = null; Type systemType = m_context.Factory.GetSystemType(typeId); // decode known type. if (systemType != null) { PushNamespace(m_reader.NamespaceURI); encodeable = ReadEncodeable(m_reader.LocalName, systemType); PopNamespace(); return encodeable; } // return undecoded xml body. document.InnerXml = m_reader.ReadOuterXml(); return document.DocumentElement; }
/// <summary cref="ITypeTable.FindSubTypes(ExpandedNodeId)" /> public IList<NodeId> FindSubTypes(ExpandedNodeId typeId) { List<NodeId> subtypes = new List<NodeId>(); if (typeId == null) { return subtypes; } NodeId localId = ExpandedNodeId.ToNodeId(typeId, m_namespaceUris); if (localId == null) { return subtypes; } lock (m_lock) { TypeInfo typeInfo = null; if (m_nodes.TryGetValue(localId, out typeInfo)) { typeInfo.GetSubtypes(subtypes); } return subtypes; } }
/// <summary> /// Adds the reference to the node. /// </summary> /// <param name="referenceTypeId">The reference type identifier.</param> /// <param name="isInverse">if set to <c>true</c> this is inverse reference.</param> /// <param name="targetId">The target identifier.</param> public void Add(NodeId referenceTypeId, bool isInverse, ExpandedNodeId targetId) { m_references[new ReferenceNode(referenceTypeId, isInverse, targetId)] = null; }
private ServiceResult OnUserArrayValue2( ISystemContext context, MethodState method, NodeId objectId, DateTime[] dateTimeIn, Uuid[] guidIn, byte[][] byteStringIn, XmlElement[] xmlElementIn, NodeId[] nodeIdIn, ExpandedNodeId[] expandedNodeIdIn, QualifiedName[] qualifiedNameIn, LocalizedText[] localizedTextIn, StatusCode[] statusCodeIn, Variant[] variantIn, ref DateTime[] dateTimeOut, ref Uuid[] guidOut, ref byte[][] byteStringOut, ref XmlElement[] xmlElementOut, ref NodeId[] nodeIdOut, ref ExpandedNodeId[] expandedNodeIdOut, ref QualifiedName[] qualifiedNameOut, ref LocalizedText[] localizedTextOut, ref StatusCode[] statusCodeOut, ref Variant[] variantOut) { dateTimeOut = dateTimeIn; guidOut = guidIn; byteStringOut = byteStringIn; xmlElementOut = xmlElementIn; nodeIdOut = nodeIdIn; expandedNodeIdOut = expandedNodeIdIn; qualifiedNameOut = qualifiedNameIn; localizedTextOut = localizedTextIn; statusCodeOut = statusCodeIn; variantOut = variantIn; return ServiceResult.Good; }
/// <summary cref="ITypeTable.IsTypeOf(ExpandedNodeId, ExpandedNodeId)" /> public bool IsTypeOf(ExpandedNodeId subTypeId, ExpandedNodeId superTypeId) { if (NodeId.IsNull(subTypeId) || subTypeId.ServerIndex != 0) { return false; } if (NodeId.IsNull(superTypeId) || superTypeId.ServerIndex != 0) { return false; } // check for exact match. if (subTypeId == superTypeId) { return true; } NodeId startId = ExpandedNodeId.ToNodeId(subTypeId, m_namespaceUris); if (startId == null) { return false; } NodeId targetId = ExpandedNodeId.ToNodeId(superTypeId, m_namespaceUris); if (targetId == null) { return false; } lock (m_lock) { TypeInfo typeInfo = null; if (!m_nodes.TryGetValue(startId, out typeInfo)) { return false; } return typeInfo.IsTypeOf(targetId); } }
/// <summary> /// Reads an ExpandedNodeId from the stream. /// </summary> public ExpandedNodeId ReadExpandedNodeId(string fieldName) { ExpandedNodeId value = new ExpandedNodeId(); if (BeginField(fieldName, true)) { PushNamespace(Namespaces.OpcUaXsd); value.IdentifierText = ReadString("Identifier"); PopNamespace(); EndField(fieldName); } if (m_namespaceMappings != null && m_namespaceMappings.Length > value.NamespaceIndex) { value.SetNamespaceIndex(m_namespaceMappings[value.NamespaceIndex]); } if (m_serverMappings != null && m_serverMappings.Length > value.ServerIndex) { value.SetServerIndex(m_serverMappings[value.NamespaceIndex]); } return value; }
/// <summary cref="ITypeTable.IsEncodingOf(ExpandedNodeId, ExpandedNodeId)" /> public bool IsEncodingOf(ExpandedNodeId encodingId, ExpandedNodeId datatypeId) { // check for invalid ids. if (NodeId.IsNull(encodingId) || NodeId.IsNull(datatypeId)) { return false; } NodeId localId = ExpandedNodeId.ToNodeId(encodingId, m_namespaceUris); if (localId == null) { return false; } NodeId localTypeId = ExpandedNodeId.ToNodeId(datatypeId, m_namespaceUris); if (localTypeId == null) { return false; } lock (m_lock) { // lookup the immediate basetype of the subtype. TypeInfo typeInfo = null; if (!m_encodings.TryGetValue(localId, out typeInfo)) { return false; } // the encoding is a representation of the expected datatype id. if (localTypeId == typeInfo.NodeId) { return true; } // check if the encoding is a representation of a subtype of the expected datatype id. TypeInfo superTypeInfo = typeInfo.SuperType; while (superTypeInfo != null) { if (!superTypeInfo.Deleted && superTypeInfo.NodeId == localTypeId) { return true; } superTypeInfo = superTypeInfo.SuperType; } // no match. return false; } }
/// <summary> /// Creates an operand that references a component/property of a type. /// </summary> /// <param name="context">The context.</param> /// <param name="nodeId">The node identifier.</param> /// <param name="relativePath">The relative path.</param> public AttributeOperand( FilterContext context, ExpandedNodeId nodeId, RelativePath relativePath) { m_nodeId = ExpandedNodeId.ToNodeId(nodeId, context.NamespaceUris); m_browsePath = relativePath; m_attributeId = Attributes.Value; m_indexRange = null; m_alias = null; }
/// <summary cref="ITypeTable.FindDataTypeId(ExpandedNodeId)" /> public NodeId FindDataTypeId(ExpandedNodeId encodingId) { NodeId localId = ExpandedNodeId.ToNodeId(encodingId, m_namespaceUris); if (localId == null) { return NodeId.Null; } lock (m_lock) { TypeInfo typeInfo = null; if (!m_encodings.TryGetValue(localId, out typeInfo)) { return NodeId.Null; } return typeInfo.NodeId; } }
/// <summary> /// Writes an ExpandedNodeId to the stream. /// </summary> public void WriteExpandedNodeId(string fieldName, ExpandedNodeId value) { if (BeginField(fieldName, value == null, true)) { PushNamespace(Namespaces.OpcUaXsd); if (value != null) { ushort namespaceIndex = value.NamespaceIndex; if (m_namespaceMappings != null && m_namespaceMappings.Length > namespaceIndex) { namespaceIndex = m_namespaceMappings[namespaceIndex]; } uint serverIndex = value.ServerIndex; if (m_serverMappings != null && m_serverMappings.Length > serverIndex) { serverIndex = m_serverMappings[serverIndex]; } StringBuilder buffer = new StringBuilder(); ExpandedNodeId.Format(buffer, value.Identifier, value.IdType, namespaceIndex, value.NamespaceUri, serverIndex); WriteString("Identifier", buffer.ToString()); } PopNamespace(); EndField(fieldName); } }
/// <summary> /// Adds an encoding for an existing data type. /// </summary> public bool AddEncoding(NodeId dataTypeId, ExpandedNodeId encodingId) { NodeId localId = ExpandedNodeId.ToNodeId(encodingId, m_namespaceUris); if (localId == null) { return false; } lock (m_lock) { TypeInfo typeInfo = null; if (!m_nodes.TryGetValue(dataTypeId, out typeInfo)) { return false; } if (typeInfo.Encodings == null) { typeInfo.Encodings = new NodeId[] { localId }; } else { NodeId[] encodings = new NodeId[typeInfo.Encodings.Length + 1]; System.Array.Copy(typeInfo.Encodings, encodings, typeInfo.Encodings.Length); encodings[encodings.Length - 1] = localId; typeInfo.Encodings = encodings; } m_encodings[localId] = typeInfo; return true; } }
/// <summary> /// Finds the service identified by the request type. /// </summary> protected ServiceDefinition FindService(ExpandedNodeId requestTypeId) { ServiceDefinition service = null; if (!SupportedServices.TryGetValue(requestTypeId, out service)) { throw ServiceResultException.Create( StatusCodes.BadServiceUnsupported, "'{0}' is an unrecognized service identifier.", requestTypeId); } return service; }
/// <summary> /// Recursively collects the nodes within a type hierarchy. /// </summary> private void UpdateInstanceHierarchyWithInstance( HierarchyBrowsePath parent, ExpandedNodeId instanceId, InstanceDeclarationHierarchy hierarchy) { INode instance = m_nodes.Find(instanceId) as INode; // ignore instances not in the address space. if (instance == null) { return; } // must be an object, variable or method. if ((instance.NodeClass & (NodeClass.Object | NodeClass.Variable | NodeClass.Method)) == 0) { return; } // construct the browse path that identifies the node. string browsePath = null; if (parent.BrowsePath == "/") { browsePath = Utils.Format("/{0}", instance.BrowseName); } else { browsePath = Utils.Format("{0}/{1}", parent.BrowsePath, instance.BrowseName); } // check if the browse path exists in the hierarchy. HierarchyBrowsePath child = null; if (!hierarchy.BrowsePaths.TryGetValue(browsePath, out child)) { return; } // update the instance. child.InstanceId = instance.NodeId; // check if already followed. if (hierarchy.Instances.ContainsKey((NodeId)instance.NodeId)) { return; } // save child. hierarchy.Instances.Add((NodeId)instance.NodeId, instance); // check for local node. ILocalNode localInstance = instance as ILocalNode; if (localInstance == null) { return; } // follow children. foreach (IReference reference in localInstance.References.Find(ReferenceTypeIds.HierarchicalReferences, false, true, m_nodes.TypeTree)) { UpdateInstanceHierarchyWithInstance(child, reference.TargetId, hierarchy); } }