/// <summary> /// Creates a new browser object with a set of filters. /// </summary> /// <param name="context">The system context to use.</param> /// <param name="view">The view which may restrict the set of references/nodes found.</param> /// <param name="referenceType">The type of references being followed.</param> /// <param name="includeSubtypes">Whether subtypes of the reference type are followed.</param> /// <param name="browseDirection">Which way the references are being followed.</param> /// <param name="browseName">The browse name of a specific target (used when translating browse paths).</param> /// <param name="additionalReferences">Any additional references that should be included.</param> /// <param name="internalOnly">If true the browser should not making blocking calls to external systems.</param> /// <param name="source">The segment being accessed.</param> public SegmentBrowser( ISystemContext context, ViewDescription view, NodeId referenceType, bool includeSubtypes, BrowseDirection browseDirection, QualifiedName browseName, IEnumerable <IReference> additionalReferences, bool internalOnly, SegmentState source) : base( context, view, referenceType, includeSubtypes, browseDirection, browseName, additionalReferences, internalOnly) { _source = source; _stage = Stage.Begin; }
/// <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 is ParsedNodeId parsedNodeId)) { return(null); } NodeState root = null; // validate a segment. if (parsedNodeId.RootType == ModelUtils.Segment) { var segment = _system.FindSegment(parsedNodeId.RootId); // segment does not exist. if (segment == null) { return(null); } var 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 (parsedNodeId.RootType == ModelUtils.Block) { // validate the block. var block = _system.FindBlock(parsedNodeId.RootId); // block does not exist. if (block == null) { return(null); } var rootId = ModelUtils.ConstructIdForBlock(block.Id, NamespaceIndex); // check for check for blocks that are being currently monitored. if (_blocks.TryGetValue(rootId, out var 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(parsedNodeId.ComponentPath)) { handle.Validated = true; handle.Node = target = root; return(handle.Node); } // validate component. NodeState component = root.FindChildBySymbolicName(context, 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); } } }