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