Opc.Ua.Server.Subscription.PublishTimerExpired C# (CSharp) Method

		public PublishingState PublishTimerExpired()
        {
            lock (m_lock)
            {
                long currentTime = HiResClock.UtcNow.Ticks/TimeSpan.TicksPerMillisecond;
                
                // check if publish interval has elapsed.
                if (m_publishTimerExpiry >= currentTime)
                {
                    // check if waiting for publish.
                    if (m_waitingForPublish)
                    {                      
                        return PublishingState.WaitingForPublish;
                    }

                    return PublishingState.Idle;
                }
                
                // set next expiry time.
                while (m_publishTimerExpiry < currentTime)
                {
                    m_publishTimerExpiry += (long)m_publishingInterval;
                }

                // check lifetime has elapsed.
                if (m_waitingForPublish)
                {
                    m_lifetimeCounter++;

                    lock (m_diagnostics)
                    {
                        m_diagnostics.LatePublishRequestCount++;
                        m_diagnostics.CurrentLifetimeCount = m_lifetimeCounter;
                    }
                    
                    if (m_lifetimeCounter >= m_maxLifetimeCount)
                    {                        
                        TraceState("EXPIRED");
                        return PublishingState.Expired;
                    }
                }

                // increment keep alive counter.
                m_keepAliveCounter++;
                
                lock (m_diagnostics)
                {
                    m_diagnostics.CurrentKeepAliveCount = m_keepAliveCounter;
                }

                // check for monitored items.
                if (m_publishingEnabled && m_session != null)
                {                  
                    // check for monitored items that are ready to publish.
                    LinkedListNode<IMonitoredItem> current = m_itemsToCheck.First;
                    bool itemsTriggered = false;

                    while (current != null)
                    {
                        LinkedListNode<IMonitoredItem> next = current.Next;
                        IMonitoredItem monitoredItem = current.Value;

                        // check if the item is ready to publish.
                        if (monitoredItem.IsReadyToPublish)
                        {
                            m_itemsToCheck.Remove(current);
                            m_itemsToPublish.AddLast(current);
                        }

                        // update any triggered items.
                        List<ITriggeredMonitoredItem> triggeredItems = null;

                        if (monitoredItem.IsReadyToTrigger)
                        {
                            if (m_itemsToTrigger.TryGetValue(current.Value.Id, out triggeredItems))
                            {
                                for (int ii = 0; ii < triggeredItems.Count; ii++)
                                {
                                    if (triggeredItems[ii].SetTriggered())
                                    {
                                        itemsTriggered = true;
                                    }
                                }

                                // clear ReadyToTrigger flag after trigger
                                monitoredItem.IsReadyToTrigger = false;
                            }
                        }

                        current = next;
                    }

                    // need to go through the list again if items were triggered.
                    if (itemsTriggered)
                    {
                        current = m_itemsToCheck.First;

                        while (current != null)
                        {
                            LinkedListNode<IMonitoredItem> next = current.Next;
                            IMonitoredItem monitoredItem = current.Value;

                            if (monitoredItem.IsReadyToPublish)
                            {
                                m_itemsToCheck.Remove(current);
                                m_itemsToPublish.AddLast(current);
                            }

                            current = next;
                        }
                    }

                    if (m_itemsToPublish.Count > 0)
                    {
                        if (!m_waitingForPublish)
                        {
                            // TraceState("READY TO PUBLISH");
                        }

                        m_waitingForPublish = true;
                        return PublishingState.NotificationsAvailable;
                    }
                }                
                
                // check if keep alive expired.
                if (m_keepAliveCounter >= m_maxKeepAliveCount)
                {
                    if (!m_waitingForPublish)
                    {
                        // TraceState("READY TO KEEPALIVE");
                    }

                    m_waitingForPublish = true;
                    return PublishingState.NotificationsAvailable;
                }
                
                // do nothing.
                return PublishingState.Idle;
            }
        }