//******************************************************************************************************//  ChannelValueBase.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/07/2005 - J. Ritchie Carroll//       Generated original version of source code.//  08/07/2009 - Josh L. Patterson//       Edited Comments.//  09/15/2009 - Stephen C. Wills//       Added new header and license agreement.//  10/5/2012 - Gavin E. Holden//       Added new header and license agreement.//  12/17/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Runtime.Serialization;using GSF.TimeSeries; namespace GSF.PhasorProtocols{    /// <summary>    /// Represents the common implementation of the protocol independent representation of any kind of data value.    /// </summary>    /// <typeparam name="T">Generic type.</typeparam>    [Serializable]    public abstract class ChannelValueBase<T> : ChannelBase, IChannelValue<T> where T : IChannelDefinition    {        #region [ Members ]         // Fields        private IDataCell m_parent;        private T m_definition;        private IMeasurement[] m_measurements;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="ChannelValueBase{T}"/> from specified parameters.        /// </summary>        /// <param name="parent">The <see cref="IDataCell"/> parent of this <see cref="ChannelValueBase{T}"/>.</param>        /// <param name="channelDefinition">The <see cref="IChannelDefinition"/> associated with this <see cref="ChannelValueBase{T}"/>.</param>        protected ChannelValueBase(IDataCell parent, T channelDefinition)        {            m_parent = parent;            m_definition = channelDefinition;        }         /// <summary>        /// Creates a new <see cref="ChannelValueBase{T}"/> from serialization parameters.        /// </summary>        /// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>        /// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>        protected ChannelValueBase(SerializationInfo info, StreamingContext context)        {            // Deserialize channel value            m_parent = (IDataCell)info.GetValue("parent", typeof(IDataCell));            m_definition = (T)info.GetValue("definition", typeof(T));        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets the <see cref="IDataCell"/> parent of this <see cref="ChannelValueBase{T}"/>.        /// </summary>        public virtual IDataCell Parent        {            get => m_parent;            set => m_parent = value;        }         /// <summary>        /// Gets or sets the <see cref="IChannelDefinition"/> associated with this <see cref="ChannelValueBase{T}"/>.        /// </summary>        public virtual T Definition        {            get => m_definition;            set => m_definition = value;        }         /// <summary>        /// Gets the <see cref="PhasorProtocols.DataFormat"/> of this <see cref="ChannelValueBase{T}"/>.        /// </summary>        public virtual DataFormat DataFormat => m_definition.DataFormat;         /// <summary>        /// Gets text based label of this <see cref="ChannelValueBase{T}"/>.        /// </summary>        public virtual string Label => m_definition.Label;         /// <summary>        /// Gets boolean value that determines if none of the composite values of <see cref="ChannelValueBase{T}"/> have been assigned a value.        /// </summary>        /// <returns><c>true</c>, if no composite values have been assigned a value; otherwise, <c>false</c>.</returns>        public abstract bool IsEmpty { get; }         /// <summary>        /// Gets total number of composite values that this <see cref="ChannelValueBase{T}"/> provides.        /// </summary>        public abstract int CompositeValueCount { get; }         /// <summary>        /// Gets the composite values of this <see cref="ChannelValueBase{T}"/> as an array of <see cref="IMeasurement"/> values.        /// </summary>        public virtual IMeasurement[] Measurements        {            get            {                // Create a measurement instance for each composite value the derived channel value exposes                if (m_measurements is null)                {                    m_measurements = new IMeasurement[CompositeValueCount];                     // ChannelValueMeasurement dynamically accesses CompositeValues[x] for its value                    for (int x = 0; x < m_measurements.Length; x++)                        m_measurements[x] = CreateMeasurement(x);                }                 return m_measurements;            }        }         /// <summary>        /// <see cref="Dictionary{TKey,TValue}"/> of string based property names and values for the <see cref="ChannelValueBase{T}"/> object.        /// </summary>        public override Dictionary<string, string> Attributes        {            get            {                Dictionary<string, string> baseAttributes = base.Attributes;                int compositeValues = CompositeValueCount;                 baseAttributes.Add("Label", Label);                baseAttributes.Add("Data Format", $"{(int)DataFormat}: {DataFormat}");                baseAttributes.Add("Is Empty", IsEmpty.ToString());                baseAttributes.Add("Total Composite Values", compositeValues.ToString());                 for (int x = 0; x < compositeValues; x++)                {                    baseAttributes.Add($"     Composite Value {x}", $" => {GetCompositeValue(x)}");                }                 return baseAttributes;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Gets the specified composite value of this <see cref="ChannelValueBase{T}"/>.        /// </summary>        /// <param name="index">Index of composite value to retrieve.</param>        /// <remarks>        /// Some <see cref="ChannelValueBase{T}"/> implementations can contain more than one value, this method is used to abstractly expose each value.        /// </remarks>        /// <returns>A <see cref="double"/> representing the composite value.</returns>        public abstract double GetCompositeValue(int index);         /// <summary>        /// Creates a new <see cref="IMeasurement"/> value for specified composite value for this <see cref="ChannelValueBase{T}"/>.        /// </summary>        /// <param name="valueIndex">Composite value index for which to derive new <see cref="IMeasurement"/> value.</param>        /// <returns>New <see cref="IMeasurement"/> value for specified composite value for this <see cref="ChannelValueBase{T}"/>.</returns>        protected virtual IMeasurement CreateMeasurement(int valueIndex)        {            Measurement measurement = new()            {                Timestamp = Parent.Parent.Timestamp,                Value = GetCompositeValue(valueIndex)            };             measurement.StateFlags =                (Parent.SynchronizationIsValid && measurement.Timestamp.Value != -1 ? MeasurementStateFlags.Normal : MeasurementStateFlags.BadTime) |                (Parent.DataIsValid ? MeasurementStateFlags.Normal : MeasurementStateFlags.BadData) |                (Parent.DeviceError ? MeasurementStateFlags.SystemError : MeasurementStateFlags.Normal);             return measurement;        }         /// <summary>        /// Populates a <see cref="SerializationInfo"/> with the data needed to serialize the target object.        /// </summary>        /// <param name="info">The <see cref="SerializationInfo"/> to populate with data.</param>        /// <param name="context">The destination <see cref="StreamingContext"/> for this serialization.</param>        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)        {            // Serialize channel value            info.AddValue("parent", m_parent, typeof(IDataCell));            info.AddValue("definition", m_definition, typeof(T));        }         #endregion    }}