//******************************************************************************************************//  IntercomRecord.cs - Gbtc////  Copyright © 2012, 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 MIT License (MIT), 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/MIT////  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://  ----------------------------------------------------------------------------------------------------//  03/09/2007 - Pinal C. Patel//       Generated original version of code based on DatAWare system specifications by Brian B. Fox, GSF.//  04/17/2009 - Pinal C. Patel//       Converted to C#.//  09/15/2009 - Stephen C. Wills//       Added new header and license agreement.//  10/11/2010 - Mihir Brahmbhatt//       Updated header and license agreement.//  11/30/2011 - J. Ritchie Carroll//       Modified to support buffer optimized ISupportBinaryImage.//  12/14/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.Collections.Generic;using GSF.Parsing; namespace GSF.Historian.Files{    /// <summary>    /// Represents a record in the <see cref="IntercomFile"/> that contains runtime information of a historian.    /// </summary>    /// <seealso cref="IntercomFile"/>    public class IntercomRecord : ISupportBinaryImage    {        // **************************************************************************************************        // *                                        Binary Structure                                        *        // **************************************************************************************************        // * # Of Bytes Byte Index Data Type  Property Name                                                 *        // * ---------- ---------- ---------- --------------------------------------------------------------*        // * 4          0-3        Int32      DataBlocksUsed                                                *        // * 4          4-7        Boolean    RolloverInProggress                                           *        // * 8          8-15       Double     LatestDataTime                                                *        // * 4          16-19      Int32      LatestDataID                                                  *        // * 160        20-179     Double(20) SourceLatestDataTime                                                     *        // **************************************************************************************************         #region [ Members ]         // Constants         /// <summary>        /// Specifies the number of bytes in the binary image of <see cref="IntercomRecord"/>.        /// </summary>        public const int FixedLength = 180;         // Fields        private int m_recordID;        private int m_dataBlocksUsed;        private bool m_rolloverInProgress;        private TimeTag m_latestDataTime;        private int m_latestDataID;        private readonly List<TimeTag> m_sourceLatestDataTime;         #endregion         #region [ Constructors ]         /// <summary>        /// Initializes a new instance of the <see cref="IntercomRecord"/> class.        /// </summary>        /// <param name="recordID">ID of the <see cref="IntercomRecord"/>.</param>        public IntercomRecord(int recordID)        {            m_recordID = recordID;            m_latestDataTime = TimeTag.MinValue;            m_sourceLatestDataTime = new List<TimeTag>();             for (int i = 0; i < 20; i++)            {                m_sourceLatestDataTime.Add(TimeTag.MinValue);            }        }         /// <summary>        /// Initializes a new instance of the <see cref="IntercomRecord"/> class.        /// </summary>        /// <param name="recordID">ID of the <see cref="IntercomRecord"/>.</param>        /// <param name="buffer">Binary image to be used for initializing <see cref="IntercomRecord"/>.</param>        /// <param name="startIndex">0-based starting index of initialization data in the <paramref name="buffer"/>.</param>        /// <param name="length">Valid number of bytes in <paramref name="buffer"/> from <paramref name="startIndex"/>.</param>        public IntercomRecord(int recordID, byte[] buffer, int startIndex, int length)            : this(recordID)        {            ParseBinaryImage(buffer, startIndex, length);        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets the number of allocated <see cref="ArchiveDataBlock"/>s in the active <see cref="ArchiveFile"/>.        /// </summary>        /// <exception cref="ArgumentException">The value being assigned is not positive or zero.</exception>        public int DataBlocksUsed        {            get            {                lock (this)                {                    return m_dataBlocksUsed;                }            }            set            {                if (value < 0)                    throw new ArgumentException("Value must be positive or zero");                 lock (this)                {                    m_dataBlocksUsed = value;                }            }        }         /// <summary>        /// Gets or sets a boolean value that indicates whether the active <see cref="ArchiveFile"/> if being rolled-over.        /// </summary>        public bool RolloverInProgress        {            get            {                lock (this)                {                    return m_rolloverInProgress;                }            }            set            {                lock (this)                {                    m_rolloverInProgress = value;                }            }        }         /// <summary>        /// Gets or sets the <see cref="TimeTag"/> of latest <see cref="ArchiveDataPoint"/> received by the active <see cref="ArchiveFile"/>.        /// </summary>        public TimeTag LatestDataTime        {            get            {                lock (this)                {                    return m_latestDataTime;                }            }            set            {                lock (this)                {                    m_latestDataTime = value;                }            }        }         /// <summary>        /// Gets or sets the historian identifier of latest <see cref="ArchiveDataPoint"/> received by the active <see cref="ArchiveFile"/>.        /// </summary>        public int LatestDataID        {            get            {                lock (this)                {                    return m_latestDataID;                }            }            set            {                lock (this)                {                    m_latestDataID = value;                }            }        }         /// <summary>        /// Gets a list of <see cref="TimeTag"/>s of the latest <see cref="ArchiveDataPoint"/> received from each of the <see cref="MetadataRecord.SourceID"/>s.        /// </summary>        public IList<TimeTag> SourceLatestDataTime        {            get            {                lock (this)                {                    return m_sourceLatestDataTime.AsReadOnly();                }            }        }         /// <summary>        /// Gets the length of the <see cref="IntercomRecord"/>.        /// </summary>        public int BinaryLength        {            get            {                return FixedLength;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Initializes <see cref="IntercomRecord"/> from the specified <paramref name="buffer"/>.        /// </summary>        /// <param name="buffer">Binary image to be used for initializing <see cref="IntercomRecord"/>.</param>        /// <param name="startIndex">0-based starting index of initialization data in the <paramref name="buffer"/>.</param>        /// <param name="length">Valid number of bytes in <paramref name="buffer"/> from <paramref name="startIndex"/>.</param>        /// <returns>Number of bytes used from the <paramref name="buffer"/> for initializing <see cref="IntercomRecord"/>.</returns>        public int ParseBinaryImage(byte[] buffer, int startIndex, int length)        {            if (length >= FixedLength)            {                // Binary image has sufficient data.                DataBlocksUsed = LittleEndian.ToInt32(buffer, startIndex);                RolloverInProgress = LittleEndian.ToBoolean(buffer, startIndex + 4);                LatestDataTime = new TimeTag((decimal)LittleEndian.ToDouble(buffer, startIndex + 8));                LatestDataID = LittleEndian.ToInt32(buffer, startIndex + 16);                 for (int i = 0; i < m_sourceLatestDataTime.Count; i++)                {                    m_sourceLatestDataTime[i] = new TimeTag((decimal)LittleEndian.ToDouble(buffer, startIndex + 20 + (i * 8)));                }                 return FixedLength;            }            else            {                // Binary image does not have sufficient data.                return 0;            }        }         /// <summary>        /// Generates binary image of the <see cref="IntercomRecord"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes.        /// </summary>        /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param>        /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param>        /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns>        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception>        /// <exception cref="ArgumentOutOfRangeException">        /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or-         /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length.        /// </exception>        public virtual int GenerateBinaryImage(byte[] buffer, int startIndex)        {            int length = BinaryLength;             buffer.ValidateParameters(startIndex, length);             lock (this)            {                Buffer.BlockCopy(LittleEndian.GetBytes(m_dataBlocksUsed), 0, buffer, startIndex, 4);                Buffer.BlockCopy(LittleEndian.GetBytes(Convert.ToInt32(m_rolloverInProgress)), 0, buffer, startIndex + 4, 4);                Buffer.BlockCopy(LittleEndian.GetBytes((double)m_latestDataTime.Value), 0, buffer, startIndex + 8, 8);                Buffer.BlockCopy(LittleEndian.GetBytes(m_latestDataID), 0, buffer, startIndex + 16, 4);                 for (int i = 0; i < m_sourceLatestDataTime.Count; i++)                {                    Buffer.BlockCopy(LittleEndian.GetBytes((double)m_sourceLatestDataTime[i].Value), 0, buffer, startIndex + 20 + (i * 8), 8);                }            }             return length;        }         #endregion    }}