//******************************************************************************************************//  LogStackTrace.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;using System.Collections.ObjectModel;using System.Data;using System.Diagnostics;using System.IO;using System.Text;using GSF.IO; namespace GSF.Diagnostics{    /// <summary>    /// Provides stack trace data that can be serialized to a stream.    /// </summary>    public class LogStackTrace        : IEquatable<LogStackTrace>    {        /// <summary>        /// Gets the stack frame data        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        private readonly List<LogStackFrame> m_frames;         /// <summary>        /// Gets the stack frame data        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly ReadOnlyCollection<LogStackFrame> Frames;         /// <summary>        /// Gets the hashcode for this class        /// </summary>        private readonly int m_hashCode;         /// <summary>        /// Creates the <see cref="LogStackTrace.Empty"/> object        /// </summary>        private LogStackTrace()        {            m_frames = new List<LogStackFrame>();            Frames = new ReadOnlyCollection<LogStackFrame>(m_frames);        }         /// <summary>        /// Creates a stack trace object        /// </summary>        /// <param name="lookupFileInfo">gets if the file paths need to be looked up.</param>        /// <param name="skipCount">the number of frames to skip.</param>        /// <param name="maxStackFrames">the maximum number of frames in the stack trace.</param>        public LogStackTrace(bool lookupFileInfo = true, int skipCount = 0, int maxStackFrames = int.MaxValue)        {            m_frames = new List<LogStackFrame>();            Frames = new ReadOnlyCollection<LogStackFrame>(m_frames);            try            {                var trace = new StackTrace(skipCount + 1, lookupFileInfo);                var frames = trace.GetFrames();                if (frames != null)                {                    foreach (var frame in frames)                    {                        if (maxStackFrames <= 0)                            break;                        maxStackFrames--;                        m_frames.Add(new LogStackFrame(frame));                    }                }            }            catch (Exception)            {                //Sometimes a stack trace can not be obtained. Just silently ignore this error.            }            m_hashCode = ComputeHashCode();        }         /// <summary>        /// Loads stack trace information from the supplied <see param="stream"/>        /// </summary>        /// <param name="stream">where to load the stack trace information</param>        public LogStackTrace(Stream stream)        {            byte version = stream.ReadNextByte();            switch (version)            {                case 1:                    int count = stream.ReadInt32();                    m_frames = new List<LogStackFrame>(count);                    Frames = new ReadOnlyCollection<LogStackFrame>(m_frames);                    while (count > 0)                    {                        count--;                        m_frames.Add(new LogStackFrame(stream));                    }                    break;                default:                    throw new VersionNotFoundException("Unknown StackTraceDetails Version");            }            m_hashCode = ComputeHashCode();        }         private int ComputeHashCode()        {            int code = Frames.Count;            foreach (var frame in Frames)            {                code ^= frame.ComputeHashCode();            }            return code;        }         /// <summary>        /// Saves stack trace information to the supplied <see param="stream"/>        /// </summary>        /// <param name="stream">where to save the stack trace information</param>        public void Save(Stream stream)        {            stream.Write((byte)1);            stream.Write(Frames.Count);            foreach (var frame in Frames)            {                frame.Save(stream);            }        }         /// <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()        {            if (Frames.Count == 0)                return string.Empty;            StringBuilder sb = new StringBuilder();            foreach (var frame in Frames)            {                sb.Append("   at ");                frame.ToString(sb);                sb.AppendLine();            }            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 LogStackTrace);        }         /// <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="other"/> parameter; otherwise, false.        /// </returns>        /// <param name="other">An object to compare with this object.</param>        public bool Equals(LogStackTrace other)        {            if (ReferenceEquals(this, other))                return true;            if ((object)other == null                || m_hashCode != other.m_hashCode                || Frames.Count != other.Frames.Count)                return false;            for (int x = 0; x < Frames.Count; x++)            {                if (!Frames[x].Equals(other.Frames[x]))                    return false;            }            return true;        }         #region [ Static ]         /// <summary>        /// An empty stack trace.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public static readonly LogStackTrace Empty;         static LogStackTrace()        {            Empty = new LogStackTrace();        }         internal static void Initialize()        {         }         #endregion    }}