//******************************************************************************************************//  LogEventPublisherDetails.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.Data;using System.IO;using System.Text;using GSF.IO; namespace GSF.Diagnostics{    /// <summary>    /// Information about the <see cref="LogEventPublisher"/> that published this message.    /// </summary>    /// <remarks>    /// Since it is likely that a log file will have this data repeated a bunch, this class allows    /// de-duplication of this data so it takes up less memory to store.    /// </remarks>    public sealed class LogEventPublisherDetails        : IEquatable<LogEventPublisherDetails>    {        /// <summary>        /// The <see cref="PublisherTypeDefinition"/> associated with <see cref="LogPublisher"/> that generated the message.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly PublisherTypeDefinition TypeData;         /// <summary>        /// The event name of this log message.        /// </summary>        public readonly string EventName;         /// <summary>        /// A hashCode code of this owner.        /// </summary>        private readonly int m_hashCode;         /// <summary>        /// Loads a log messages from the supplied stream        /// </summary>        /// <param name="stream">the stream to load the log message from.</param>        /// <param name="helper">the helper to assist in loading/saving</param>        internal LogEventPublisherDetails(Stream stream, LogMessageSaveHelper helper)        {            byte version = stream.ReadNextByte();            switch (version)            {                case 1:                    string typeName = stream.ReadString();                    string assemblyName = stream.ReadString();                    TypeData = new PublisherTypeDefinition(typeName, assemblyName);                    EventName = stream.ReadString();                    break;                case 2:                    EventName = stream.ReadString();                    TypeData = helper.LoadPublisherTypeDefinition(stream);                    break;                default:                    throw new VersionNotFoundException();            }            m_hashCode = ComputeHashCode();        }         /// <summary>        /// Represents a single owner of a log message.        /// </summary>        public LogEventPublisherDetails(PublisherTypeDefinition typeData, string eventName)        {            if (typeData == null)                throw new ArgumentNullException(nameof(typeData));            if (eventName == null)                eventName = string.Empty;            TypeData = typeData;            EventName = eventName;            m_hashCode = ComputeHashCode();        }         private int ComputeHashCode()        {            return TypeData.GetHashCode() ^ EventName.GetHashCode();        }         /// <summary>        /// Writes the log data to the stream        /// </summary>        /// <param name="stream"></param>        /// <param name="helper">the helper to assist in loading/saving</param>        internal void Save(Stream stream, LogMessageSaveHelper helper)        {            stream.Write((byte)2);            stream.Write(EventName);            helper.SavePublisherTypeDefinition(stream, TypeData);        }         /// <summary>        /// Returns a string that represents the current object.        /// </summary>        /// <returns>        /// A string that represents the current object.        /// </returns>        /// <filterpriority>2</filterpriority>        public override string ToString()        {            StringBuilder sb = new StringBuilder();            if (TypeData.TypeName.Length > 0)            {                sb.AppendLine("Message Type: " + TypeData.TypeName);            }            if (TypeData.AssemblyName.Length > 0)            {                sb.AppendLine("Message Assembly: " + TypeData.AssemblyName);            }            if (EventName.Length > 0)            {                sb.AppendLine("Event: " + EventName);            }            sb.Length -= Environment.NewLine.Length;            return sb.ToString();        }         /// <summary>        /// Serves as a hash function for a particular type.         /// </summary>        /// <returns>        /// A hash code for the current <see cref="T:System.Object"/>.        /// </returns>        /// <filterpriority>2</filterpriority>        public override int GetHashCode()        {            return (int)m_hashCode;        }         /// <summary>        /// Determines whether the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>.        /// </summary>        /// <returns>        /// true if the specified object  is equal to the current object; otherwise, false.        /// </returns>        /// <param name="obj">The object to compare with the current object. </param><filterpriority>2</filterpriority>        public override bool Equals(object obj)        {            return Equals(obj as LogEventPublisherDetails);        }         /// <summary>        /// Indicates whether the current object is equal to another object of the same type.        /// </summary>        /// <returns>        /// true if the current object is equal to the <paramref name="obj"/> parameter; otherwise, false.        /// </returns>        /// <param name="obj">An object to compare with this object.</param>        public bool Equals(LogEventPublisherDetails obj)        {            if (ReferenceEquals(obj, null))                return false;            if (ReferenceEquals(this, obj))                return true;             return m_hashCode == obj.m_hashCode &&                   EventName == obj.EventName &&                   TypeData.Equals(obj.TypeData);         }      }}