/// <summary>
/// Updates the event types in cache with the most recent info fetched from the AE server.
/// </summary>
public void UpdateCache(ServerSystemContext context, ushort namespaceIndex)
{
// clear the existing nodes.
EventTypeNodes = new NodeIdDictionary <BaseObjectTypeState>();
Attributes = new Dictionary <int, int[]>();
TypeTable typeTable = context.TypeTable as TypeTable;
// rebuild from the recently fetched list.
for (int ii = 0; ii < EventTypes.Count; ii++)
{
// save the attributes for use when creating filters.
if (EventTypes[ii].EventTypeMapping != EventTypeMapping.ConditionClassType && !Attributes.ContainsKey(EventTypes[ii].CategoryId))
{
EventType eventType = EventTypes[ii];
int[] attributeIds = new int[eventType.Attributes.Count];
for (int jj = 0; jj < attributeIds.Length; jj++)
{
attributeIds[jj] = eventType.Attributes[jj].Id;
}
Attributes.Add(EventTypes[ii].CategoryId, attributeIds);
}
AeEventTypeState node = new AeEventTypeState(EventTypes[ii], namespaceIndex);
BaseObjectTypeState mappingNode = null;
if (!EventTypeNodes.TryGetValue(node.SuperTypeId, out mappingNode))
{
mappingNode = new AeEventTypeMappingState(node.EventType.EventTypeMapping, namespaceIndex);
EventTypeNodes.Add(mappingNode.NodeId, mappingNode);
// ensure the mapping node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(mappingNode.NodeId))
{
typeTable.AddSubtype(mappingNode.NodeId, mappingNode.SuperTypeId);
}
}
}
EventTypeNodes.Add(node.NodeId, node);
// ensure the type node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(node.NodeId))
{
typeTable.AddSubtype(node.NodeId, mappingNode.NodeId);
}
}
}
}
/// <summary>
/// Returns the node for the event type mapping identified by the node id.
/// </summary>
public AeEventTypeMappingState GetMappingNode(ServerSystemContext context, NodeId nodeId)
{
BaseObjectTypeState objectType = null;
if (!EventTypeNodes.TryGetValue(nodeId, out objectType))
{
return(null);
}
AeEventTypeMappingState mappingNode = objectType as AeEventTypeMappingState;
if (mappingNode == null)
{
return(null);
}
if (context.TypeTable.FindSubTypes(mappingNode.NodeId).Count == 0)
{
return(null);
}
return(mappingNode);
}
/// <summary>
/// Updates the event types in cache with the most recent info fetched from the AE server.
/// </summary>
public void UpdateCache(ServerSystemContext context, ushort namespaceIndex)
{
// clear the existing nodes.
EventTypeNodes = new NodeIdDictionary<BaseObjectTypeState>();
Attributes = new Dictionary<int,int[]>();
TypeTable typeTable = context.TypeTable as TypeTable;
// rebuild from the recently fetched list.
for (int ii = 0; ii < EventTypes.Count; ii++)
{
// save the attributes for use when creating filters.
if (EventTypes[ii].EventTypeMapping != EventTypeMapping.ConditionClassType && !Attributes.ContainsKey(EventTypes[ii].CategoryId))
{
EventType eventType = EventTypes[ii];
int[] attributeIds = new int[eventType.Attributes.Count];
for (int jj = 0; jj < attributeIds.Length; jj++)
{
attributeIds[jj] = eventType.Attributes[jj].Id;
}
Attributes.Add(EventTypes[ii].CategoryId, attributeIds);
}
AeEventTypeState node = new AeEventTypeState(EventTypes[ii], namespaceIndex);
BaseObjectTypeState mappingNode = null;
if (!EventTypeNodes.TryGetValue(node.SuperTypeId, out mappingNode))
{
mappingNode = new AeEventTypeMappingState(node.EventType.EventTypeMapping, namespaceIndex);
EventTypeNodes.Add(mappingNode.NodeId, mappingNode);
// ensure the mapping node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(mappingNode.NodeId))
{
typeTable.AddSubtype(mappingNode.NodeId, mappingNode.SuperTypeId);
}
}
}
EventTypeNodes.Add(node.NodeId, node);
// ensure the type node is in the type table.
if (typeTable != null)
{
if (!typeTable.IsKnown(node.NodeId))
{
typeTable.AddSubtype(node.NodeId, mappingNode.NodeId);
}
}
}
}
/// <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 cache.
if (cache != null)
{
NodeState node = null;
if (cache.TryGetValue(nodeId, out node))
{
return(new NodeHandle(nodeId, node));
}
}
NodeHandle handle = null;
try
{
// check if node already being monitored.
if (MonitoredNodes != null)
{
MonitoredNode2 monitoredNode2 = null;
if (MonitoredNodes.TryGetValue(nodeId, out monitoredNode2))
{
handle = new NodeHandle(nodeId, monitoredNode2.Node);
handle.MonitoredNode = monitoredNode2;
return(handle);
}
}
// check for predefined nodes.
if (PredefinedNodes != null)
{
NodeState node = null;
if (PredefinedNodes.TryGetValue(nodeId, out node))
{
return(handle = new NodeHandle(nodeId, node));
}
}
// parse the identifier.
AeParsedNodeId parsedNodeId = AeParsedNodeId.Parse(nodeId);
if (parsedNodeId != null)
{
if (parsedNodeId.RootType == AeModelUtils.AeEventTypeMapping && m_typeCache != null)
{
AeEventTypeMappingState mappingNode = m_typeCache.GetMappingNode(SystemContext, nodeId);
if (mappingNode != null)
{
return(handle = new NodeHandle(nodeId, mappingNode));
}
return(null);
}
handle = new NodeHandle();
handle.NodeId = nodeId;
handle.Validated = false;
handle.Node = null;
handle.ParsedNodeId = parsedNodeId;
return(handle);
}
}
finally
{
if (handle != null && handle.Node != null && cache != null)
{
cache.Add(nodeId, handle.Node);
}
}
return(null);
}
}
