/// <summary>
/// Constructs a NodeId for a source.
/// </summary>
/// <param name="sourceId">The source id.</param>
/// <param name="namespaceIndex">Index of the namespace.</param>
/// <returns>The new NodeId.</returns>
public static NodeId ConstructIdForSource(string sourceId, ushort namespaceIndex)
{
ParsedNodeId parsedNodeId = new ParsedNodeId();
parsedNodeId.RootId = sourceId;
parsedNodeId.NamespaceIndex = namespaceIndex;
parsedNodeId.RootType = 1;
return(parsedNodeId.Construct());
}
/// <summary>
/// Constructs a node identifier for a area.
/// </summary>
/// <param name="areaPath">The area path.</param>
/// <param name="namespaceIndex">Index of the namespace that qualifies the identifier.</param>
/// <returns>The new node identifier.</returns>
public static NodeId ConstructIdForArea(string areaPath, ushort namespaceIndex)
{
ParsedNodeId parsedNodeId = new ParsedNodeId();
parsedNodeId.RootId = areaPath;
parsedNodeId.NamespaceIndex = namespaceIndex;
parsedNodeId.RootType = 0;
return(parsedNodeId.Construct());
}
/// <summary>
/// Returns a unique handle for the node.
/// </summary>
protected override NodeHandle GetManagerHandle(ServerSystemContext context, NodeId nodeId, IDictionary <NodeId, NodeState> cache)
{
lock (Lock)
{
// quickly exclude nodes that are not in the namespace.
if (!IsNodeIdInNamespace(nodeId))
{
return(null);
}
// check for check for nodes that are being currently monitored.
MonitoredNode monitoredNode = null;
if (MonitoredNodes.TryGetValue(nodeId, out monitoredNode))
{
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = true;
handle.Node = monitoredNode.Node;
return(handle);
}
// parse the identifier.
ParsedNodeId parsedNodeId = ParsedNodeId.Parse(nodeId);
if (parsedNodeId != null)
{
NodeHandle handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = false;
handle.Node = null;
handle.ParsedNodeId = parsedNodeId;
return(handle);
}
return(null);
}
}
/// <summary>
/// Parses the specified node identifier.
/// </summary>
/// <param name="nodeId">The node identifier.</param>
/// <returns>The parsed node identifier. Null if the identifier cannot be parsed.</returns>
public static ParsedNodeId Parse(NodeId nodeId)
{
// can only parse non-null string node identifiers.
if (NodeId.IsNull(nodeId))
{
return(null);
}
string identifier = nodeId.Identifier as string;
if (String.IsNullOrEmpty(identifier))
{
return(null);
}
ParsedNodeId parsedNodeId = new ParsedNodeId();
parsedNodeId.NamespaceIndex = nodeId.NamespaceIndex;
// extract the type of identifier.
parsedNodeId.RootType = 0;
int start = 0;
for (int ii = 0; ii < identifier.Length; ii++)
{
if (!Char.IsDigit(identifier[ii]))
{
start = ii;
break;
}
parsedNodeId.RootType *= 10;
parsedNodeId.RootType += (byte)(identifier[ii] - '0');
}
if (start >= identifier.Length || identifier[start] != ':')
{
return(null);
}
// extract any component path.
StringBuilder buffer = new StringBuilder();
int index = start + 1;
int end = identifier.Length;
bool escaped = false;
while (index < end)
{
char ch = identifier[index++];
// skip any escape character but keep the one after it.
if (ch == '&')
{
escaped = true;
continue;
}
if (!escaped && ch == '?')
{
end = index;
break;
}
buffer.Append(ch);
escaped = false;
}
// extract any component.
parsedNodeId.RootId = buffer.ToString();
parsedNodeId.ComponentPath = null;
if (end < identifier.Length)
{
parsedNodeId.ComponentPath = identifier.Substring(end);
}
return(parsedNodeId);
}