/// <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);
}
}
}
