Keeps track of the monitored items for a single node.
Beispiel #1
0
 /// <summary>
 /// Constructs a new instance.
 /// </summary>
 public DataChangeMonitoredItem(
     MonitoredNode source,
     uint id,
     uint attributeId,
     NumericRange indexRange,
     QualifiedName dataEncoding,
     DiagnosticsMasks diagnosticsMasks,
     TimestampsToReturn timestampsToReturn,
     MonitoringMode monitoringMode,
     uint clientHandle,
     double samplingInterval,
     bool alwaysReportUpdates)
 {
     m_source              = source;
     m_id                  = id;
     m_attributeId         = attributeId;
     m_indexRange          = indexRange;
     m_dataEncoding        = dataEncoding;
     m_timestampsToReturn  = timestampsToReturn;
     m_diagnosticsMasks    = diagnosticsMasks;
     m_monitoringMode      = monitoringMode;
     m_clientHandle        = clientHandle;
     m_samplingInterval    = samplingInterval;
     m_nextSampleTime      = DateTime.UtcNow.Ticks;
     m_readyToPublish      = false;
     m_readyToTrigger      = false;
     m_alwaysReportUpdates = alwaysReportUpdates;
 }
        /// <summary>
        /// Constructs a new instance.
        /// </summary>
        public DataChangeMonitoredItem(
            MonitoredNode source,
            uint id,
            uint attributeId,
            NumericRange indexRange,
            QualifiedName dataEncoding,
            DiagnosticsMasks diagnosticsMasks,
            TimestampsToReturn timestampsToReturn,
            MonitoringMode monitoringMode,
            uint clientHandle,
            double samplingInterval,
            uint queueSize,
            bool discardOldest,
            DataChangeFilter filter,
            Range range,
            bool alwaysReportUpdates)
        {
            m_source              = source;
            m_id                  = id;
            m_attributeId         = attributeId;
            m_indexRange          = indexRange;
            m_dataEncoding        = dataEncoding;
            m_timestampsToReturn  = timestampsToReturn;
            m_diagnosticsMasks    = diagnosticsMasks;
            m_monitoringMode      = monitoringMode;
            m_clientHandle        = clientHandle;
            m_samplingInterval    = samplingInterval;
            m_nextSampleTime      = DateTime.UtcNow.Ticks;
            m_readyToPublish      = false;
            m_readyToTrigger      = false;
            m_resendData          = false;
            m_queue               = null;
            m_filter              = filter;
            m_range               = 0;
            m_alwaysReportUpdates = alwaysReportUpdates;

            if (range != null)
            {
                m_range = range.High - range.Low;
            }

            if (queueSize > 1)
            {
                m_queue = new MonitoredItemQueue(id);
                m_queue.SetQueueSize(queueSize, discardOldest, diagnosticsMasks);
                m_queue.SetSamplingInterval(samplingInterval);
            }
        }
 /// <summary>
 /// Does any processing after a monitored item is created.
 /// </summary>
 protected override void OnSetMonitoringMode(
     ISystemContext systemContext,
     MonitoredNode monitoredNode,
     DataChangeMonitoredItem monitoredItem,
     MonitoringMode previousMode,
     MonitoringMode currentMode)
 {
     // nothing to do.
 }
 /// <summary>
 /// Does any processing after a monitored item is deleted.
 /// </summary>
 protected override void OnDeleteMonitoredItem(
     ISystemContext systemContext,
     MonitoredNode monitoredNode,
     DataChangeMonitoredItem monitoredItem)
 {
     StopMonitoring(systemContext, monitoredNode);
 }
 /// <summary>
 /// Does any processing after a monitored item is created.
 /// </summary>
 protected override void OnModifyMonitoredItem(
     ISystemContext systemContext,
     MonitoredItemModifyRequest itemToModify,
     MonitoredNode monitoredNode,
     DataChangeMonitoredItem monitoredItem,
     double previousSamplingInterval)
 {
     // nothing to do.
 }
 /// <summary>
 /// Does any processing after a monitored item is created.
 /// </summary>
 protected override void OnCreateMonitoredItem(
     ISystemContext systemContext,
     MonitoredItemCreateRequest itemToCreate,
     MonitoredNode monitoredNode,
     DataChangeMonitoredItem monitoredItem)
 {
     StartMonitoring(systemContext, monitoredNode);
 }
        /// <summary>
        /// Returns true if the system must be scanning to provide updates for the monitored item.
        /// </summary>
        private void StopMonitoring(ISystemContext context, MonitoredNode monitoredNode)
        {
            // find the root.
            NodeState root = monitoredNode.Node.GetHierarchyRoot();
            
            // check for areas.
            AreaState area = root as AreaState;

            if (area != null)
            {
                if (m_system.MonitorArea(area, true) == 0)
                {                    
                    RemoveNodeHierarchyFromCache(context, area);
                }

                return;             
            }

            // check for controllers.
            ControllerState controller = root as ControllerState;

            if (controller != null)
            {
                if (m_system.MonitorController(controller, true) == 0)
                {                    
                    RemoveNodeHierarchyFromCache(context, controller);
                }

                return;             
            }
        }
        /// <summary>
        /// Returns true if the system must be scanning to provide updates for the monitored item.
        /// </summary>
        private void StartMonitoring(ISystemContext context, MonitoredNode monitoredNode)
        {
            // find the root.
            NodeState root = monitoredNode.Node.GetHierarchyRoot();
            
            // check for areas.
            AreaState area = root as AreaState;

            if (area != null)
            {
                m_system.MonitorArea(area, false);

                if (!m_cache.ContainsKey(area.NodeId))
                {
                    AddNodeHierarchyToCache(context, area);
                }

                return;             
            }

            // check for controllers.
            ControllerState controller = root as ControllerState;

            if (controller != null)
            {
                m_system.MonitorController(controller, false);
                
                if (!m_cache.ContainsKey(controller.NodeId))
                {
                    AddNodeHierarchyToCache(context, controller);
                }

                return;             
            }
        }
 /// <summary>
 /// Does any processing after a monitored item is deleted.
 /// </summary>
 protected override void OnDeleteMonitoredItem(
     ISystemContext systemContext,
     MonitoredNode monitoredNode,
     DataChangeMonitoredItem monitoredItem)
 {
     // TBD
 }