//******************************************************************************************************//  LogSubscriberInternal.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  10/24/2016 - Steven E. Chisholm//       Generated original version of source code. //       ////****************************************************************************************************** using System;using System.Collections.Generic; // ReSharper disable InconsistentlySynchronizedField namespace GSF.Diagnostics{    /// <summary>    /// A <see cref="LogSubscriberInternal"/> that collects logs     /// </summary>    internal class LogSubscriberInternal    {        private class SubscriptionInfo        {            public PublisherFilter PublisherFilter;            public MessageAttributeFilter AttributeFilter;            public bool IsIgnoreSubscription;             public SubscriptionInfo(PublisherFilter publisherFilter, MessageAttributeFilter attributeFilter, bool isIgnoreSubscription)            {                PublisherFilter = publisherFilter;                AttributeFilter = attributeFilter;                IsIgnoreSubscription = isIgnoreSubscription;            }        }         /// <summary>        /// Event handler for the logs that are raised.        /// </summary>        /// <remarks>        /// Any exceptions generated by this callback will be ignored.        /// </remarks>        public event NewLogMessageEventHandler NewLogMessage;         private Action m_recalculateRoutingTable;         private readonly object m_syncRoot;         private bool m_disposed;         private List<SubscriptionInfo> m_allSubscriptions;         /// <summary>        /// Since weak references are linked to this class, this is a common one that everyone can use when storing this weak reference.        /// </summary>        public readonly NullableWeakReference Reference;         /// <summary>        /// Creates a <see cref="LogSubscriberInternal"/>        /// </summary>        public LogSubscriberInternal(Action recalculateRoutingTable)        {            Reference = new NullableWeakReference(this);            m_recalculateRoutingTable = recalculateRoutingTable;            m_syncRoot = new object();            m_allSubscriptions = null;        }         /// <summary>        /// Clears all subscriptions        /// </summary>        public void Clear()        {            if (m_disposed)                return;             lock (m_syncRoot)            {                if (m_disposed)                    return;                 m_allSubscriptions = null;            }            m_recalculateRoutingTable();         }         /// <summary>        /// Adds/Modify/Deletes an existing subscription        /// </summary>        public void Subscribe(PublisherFilter publisherFilter, MessageAttributeFilter attributeFilter, bool isIgnoreSubscription)        {            if (publisherFilter == null)                throw new ArgumentNullException(nameof(publisherFilter));             if (m_disposed)                return;             lock (m_syncRoot)            {                if (m_disposed)                    return;                 if (m_allSubscriptions == null)                {                    if (attributeFilter == null)                        return;                     m_allSubscriptions = new List<SubscriptionInfo>();                    m_allSubscriptions.Add(new SubscriptionInfo(publisherFilter, attributeFilter, isIgnoreSubscription));                }                else                {                    for (int x = 0; x < m_allSubscriptions.Count; x++)                    {                        if (m_allSubscriptions[x].PublisherFilter.ContainsTheSameLogSearchCriteria(publisherFilter))                        {                            if (attributeFilter == null)                            {                                m_allSubscriptions.RemoveAt(x);                                return;                            }                            m_allSubscriptions[x].AttributeFilter = attributeFilter;                            m_allSubscriptions[x].IsIgnoreSubscription = isIgnoreSubscription;                            return;                        }                    }                    if (attributeFilter == null)                        return;                     m_allSubscriptions.Add(new SubscriptionInfo(publisherFilter, attributeFilter, isIgnoreSubscription));                }            }            m_recalculateRoutingTable();        }         /// <summary>        /// Assigns the supplied message to this subscriber.        /// </summary>        /// <param name="log">the message</param>        public void RaiseLogMessages(LogMessage log)        {            if (m_disposed)                return;             lock (m_syncRoot)            {                if (m_disposed)                    return;                 if (m_allSubscriptions == null || m_allSubscriptions.Count == 0)                    return;                 OnLog(log);            }        }         public MessageAttributeFilter GetSubscription(LogPublisherInternal publisher)        {            lock (m_syncRoot)            {                if (m_allSubscriptions == null)                    m_allSubscriptions = new List<SubscriptionInfo>();                 MessageAttributeFilter filter = new MessageAttributeFilter();                foreach (var subscription in m_allSubscriptions)                {                    if (subscription.PublisherFilter.ContainsPublisher(publisher))                    {                        if (subscription.IsIgnoreSubscription)                        {                            filter.Remove(subscription.AttributeFilter);                        }                        else                        {                            filter.Append(subscription.AttributeFilter);                        }                    }                }                return filter;            }        }         /// <summary>        /// Raises the <see cref="NewLogMessage"/> event.        /// </summary>        /// <param name="logMessage">the message to raise.</param>        private void OnLog(LogMessage logMessage)        {            if (logMessage == null)                return;            try            {                using (Logger.SuppressFirstChanceExceptionLogMessages())                {                    NewLogMessage?.Invoke(logMessage);                }            }            catch (Exception)            {                //Swallow this exception                //This is because if a subscriber throws an exception, creating a new log                //might cause an infinite loop.            }        }         /// <summary>        /// Disposes this class so future messages will not route.         /// </summary>        public void Dispose()        {            m_disposed = true;            m_allSubscriptions = null;            Reference.Clear();        }         public static readonly LogSubscriberInternal DisposedSubscriber;         static LogSubscriberInternal()        {            DisposedSubscriber = new LogSubscriberInternal(null);            DisposedSubscriber.Dispose();        }      }}