public static ConstructIdForBlock ( string blockId, ushort namespaceIndex ) : Opc.Ua.NodeId | ||
blockId | string | The block id. |
namespaceIndex | ushort | Index of the namespace. |
return | Opc.Ua.NodeId |
/// <summary> /// Returns the next child. /// </summary> private IReference NextChild() { UnderlyingSystem system = (UnderlyingSystem)this.SystemContext.SystemHandle; NodeId targetId = null; // check if a specific browse name is requested. if (!QualifiedName.IsNull(base.BrowseName)) { // check if match found previously. if (m_position == Int32.MaxValue) { return(null); } // browse name must be qualified by the correct namespace. if (m_source.BrowseName.NamespaceIndex != base.BrowseName.NamespaceIndex) { return(null); } // look for matching segment. if (m_stage == Stage.Segments && m_segments != null) { for (int ii = 0; ii < m_segments.Count; ii++) { if (base.BrowseName.Name == m_segments[ii].Name) { targetId = ModelUtils.ConstructIdForSegment(m_segments[ii].Id, m_source.NodeId.NamespaceIndex); break; } } } // look for matching block. if (m_stage == Stage.Blocks && m_blocks != null) { for (int ii = 0; ii < m_blocks.Count; ii++) { UnderlyingSystemBlock block = system.FindBlock(m_blocks[ii]); if (block != null && base.BrowseName.Name == block.Name) { targetId = ModelUtils.ConstructIdForBlock(m_blocks[ii], m_source.NodeId.NamespaceIndex); break; } } } m_position = Int32.MaxValue; } // return the child at the next position. else { // look for next segment. if (m_stage == Stage.Segments && m_segments != null) { if (m_position >= m_segments.Count) { return(null); } targetId = ModelUtils.ConstructIdForSegment(m_segments[m_position++].Id, m_source.NodeId.NamespaceIndex); } // look for next block. else if (m_stage == Stage.Blocks && m_blocks != null) { if (m_position >= m_blocks.Count) { return(null); } targetId = ModelUtils.ConstructIdForBlock(m_blocks[m_position++], m_source.NodeId.NamespaceIndex); } } // create reference. if (targetId != null) { return(new NodeStateReference(ReferenceTypeIds.Organizes, false, targetId)); } return(null); }
/// <summary> /// Verifies that the specified node exists. /// </summary> protected override NodeState ValidateNode( ServerSystemContext context, NodeHandle handle, IDictionary <NodeId, NodeState> cache) { // not valid if no root. if (handle == null) { return(null); } // check if previously validated. if (handle.Validated) { return(handle.Node); } NodeState target = null; // check if already in the cache. if (cache != null) { if (cache.TryGetValue(handle.NodeId, out target)) { // nulls mean a NodeId which was previously found to be invalid has been referenced again. if (target == null) { return(null); } handle.Node = target; handle.Validated = true; return(handle.Node); } target = null; } try { // check if the node id has been parsed. if (handle.ParsedNodeId == null) { return(null); } NodeState root = null; // validate a segment. if (handle.ParsedNodeId.RootType == ModelUtils.Segment) { UnderlyingSystemSegment segment = m_system.FindSegment(handle.ParsedNodeId.RootId); // segment does not exist. if (segment == null) { return(null); } NodeId rootId = ModelUtils.ConstructIdForSegment(segment.Id, NamespaceIndex); // create a temporary object to use for the operation. root = new SegmentState(context, rootId, segment); } // validate segment. else if (handle.ParsedNodeId.RootType == ModelUtils.Block) { // validate the block. UnderlyingSystemBlock block = m_system.FindBlock(handle.ParsedNodeId.RootId); // block does not exist. if (block == null) { return(null); } NodeId rootId = ModelUtils.ConstructIdForBlock(block.Id, NamespaceIndex); // check for check for blocks that are being currently monitored. BlockState node = null; if (m_blocks.TryGetValue(rootId, out node)) { root = node; } // create a temporary object to use for the operation. else { root = new BlockState(this, rootId, block); } } // unknown root type. else { return(null); } // all done if no components to validate. if (String.IsNullOrEmpty(handle.ParsedNodeId.ComponentPath)) { handle.Validated = true; handle.Node = target = root; return(handle.Node); } // validate component. NodeState component = root.FindChildBySymbolicName(context, handle.ParsedNodeId.ComponentPath); // component does not exist. if (component == null) { return(null); } // found a valid component. handle.Validated = true; handle.Node = target = component; return(handle.Node); } finally { // store the node in the cache to optimize subsequent lookups. if (cache != null) { cache.Add(handle.NodeId, target); } } }