//******************************************************************************************************//  SeriesInstance.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://  ----------------------------------------------------------------------------------------------------//  05/04/2012 - Stephen C. Wills, Grid Protection Alliance//       Generated original version of source code.//  12/17/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.Collections.Generic;using GSF.PQDIF.Physical; namespace GSF.PQDIF.Logical{    /// <summary>    /// Represents an instance of a series in a PQDIF file. A series    /// instance resides in a <see cref="ChannelInstance"/> and is    /// defined by a <see cref="SeriesDefinition"/>.    /// </summary>    public class SeriesInstance : IEquatable<SeriesInstance>    {        #region [ Members ]         // Fields        private readonly CollectionElement m_physicalStructure;        private readonly ChannelInstance m_channel;        private readonly SeriesDefinition m_definition;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new instance of the <see cref="SeriesInstance"/> class.        /// </summary>        /// <param name="physicalStructure">The physical structure of the series instance.</param>        /// <param name="channel">The channel instance that this series instance resides in.</param>        /// <param name="definition">The series definition that defines this series instance.</param>        public SeriesInstance(CollectionElement physicalStructure, ChannelInstance channel, SeriesDefinition definition)        {            m_physicalStructure = physicalStructure;            m_channel = channel;            m_definition = definition;        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets the physical structure of the series instance.        /// </summary>        public CollectionElement PhysicalStructure        {            get            {                return m_physicalStructure;            }        }         /// <summary>        /// Gets the channel instance in which the series instance resides.        /// </summary>        public ChannelInstance Channel        {            get            {                return m_channel;            }        }         /// <summary>        /// Gets the series definition that defines the series.        /// </summary>        public SeriesDefinition Definition        {            get            {                return m_definition;            }        }         /// <summary>        /// Gets the value by which to scale the values in        /// order to restore the original data values.        /// </summary>        public ScalarElement SeriesScale        {            get            {                return m_physicalStructure.GetScalarByTag(SeriesScaleTag)                    ?? SeriesShareSeries?.SeriesScale;            }            set            {                value.TagOfElement = SeriesScaleTag;                m_physicalStructure.RemoveElementsByTag(SeriesScaleTag);                m_physicalStructure.AddElement(value);            }        }         /// <summary>        /// Gets the value added to the values in order        /// to restore the original data values.        /// </summary>        public ScalarElement SeriesOffset        {            get            {                return m_physicalStructure.GetScalarByTag(SeriesOffsetTag)                    ?? SeriesShareSeries?.SeriesOffset;            }            set            {                value.TagOfElement = SeriesOffsetTag;                m_physicalStructure.RemoveElementsByTag(SeriesOffsetTag);                m_physicalStructure.AddElement(value);            }        }         /// <summary>        /// Gets the values contained in this series instance.        /// </summary>        public VectorElement SeriesValues        {            get            {                SeriesInstance seriesShareSeries = SeriesShareSeries;                 return ((object)seriesShareSeries != null)                    ? seriesShareSeries.SeriesValues                    : m_physicalStructure.GetVectorByTag(SeriesValuesTag);            }            set            {                value.TagOfElement = SeriesValuesTag;                m_physicalStructure.RemoveElementsByTag(SeriesValuesTag);                m_physicalStructure.AddElement(value);            }        }         /// <summary>        /// Gets the original data values, after expanding        /// sequences and scale and offset modifications.        /// </summary>        public IList<object> OriginalValues        {            get            {                return GetOriginalValues();            }        }         /// <summary>        /// Gets the index of the channel that owns the series to be shared.        /// </summary>        public uint? SeriesShareChannelIndex        {            get            {                ScalarElement seriesShareChannelIndexScalar = m_physicalStructure                    .GetScalarByTag(SeriesShareChannelIndexTag);                 return ((object)seriesShareChannelIndexScalar != null)                    ? seriesShareChannelIndexScalar.GetUInt4()                    : (uint?)null;            }            set            {                if (!value.HasValue)                {                    m_physicalStructure.RemoveElementsByTag(SeriesShareChannelIndexTag);                }                else                {                    ScalarElement seriesShareChannelIndexScalar = m_physicalStructure                        .GetOrAddScalar(SeriesShareChannelIndexTag);                     seriesShareChannelIndexScalar.TypeOfValue = PhysicalType.UnsignedInteger4;                    seriesShareChannelIndexScalar.SetUInt4(value.GetValueOrDefault());                }            }        }         /// <summary>        /// Gets the index of the series to be shared.        /// </summary>        public uint? SeriesShareSeriesIndex        {            get            {                ScalarElement seriesShareSeriesIndexScalar = m_physicalStructure                    .GetScalarByTag(SeriesShareSeriesIndexTag);                 return ((object)seriesShareSeriesIndexScalar != null)                    ? seriesShareSeriesIndexScalar.GetUInt4()                    : (uint?)null;            }            set            {                if (!value.HasValue)                {                    m_physicalStructure.RemoveElementsByTag(SeriesShareSeriesIndexTag);                }                else                {                    ScalarElement seriesShareSeriesIndexScalar = m_physicalStructure                        .GetOrAddScalar(SeriesShareSeriesIndexTag);                     seriesShareSeriesIndexScalar.TypeOfValue = PhysicalType.UnsignedInteger4;                    seriesShareSeriesIndexScalar.SetUInt4(value.GetValueOrDefault());                }            }        }         /// <summary>        /// Gets the channel that owns the series to be shared.        /// </summary>        public ChannelInstance SeriesShareChannel        {            get            {                uint? seriesShareChannelIndex = SeriesShareChannelIndex;                 return ((object)seriesShareChannelIndex != null)                    ? m_channel.ObservationRecord.ChannelInstances[(int)seriesShareChannelIndex]                    : null;            }        }         /// <summary>        /// Gets the series to be shared.        /// </summary>        public SeriesInstance SeriesShareSeries        {            get            {                uint? seriesShareSeriesIndex = SeriesShareSeriesIndex;                ChannelInstance seriesShareChannel = SeriesShareChannel;                SeriesInstance seriesShareSeries = null;                 if (((object)seriesShareSeriesIndex != null) && ((object)seriesShareChannel != null))                    seriesShareSeries = seriesShareChannel.SeriesInstances[(int)seriesShareSeriesIndex];                 return seriesShareSeries;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Sets the raw values to be written to the PQDIF file as the <see cref="SeriesValues"/>.        /// </summary>        /// <param name="values">The values to be written to the PQDIF file.</param>        public void SetValues(IList<object> values)        {            VectorElement seriesValuesElement;             seriesValuesElement = new VectorElement()            {                Size = values.Count,                TagOfElement = SeriesValuesTag,                TypeOfValue = PhysicalTypeExtensions.GetPhysicalType(values[0].GetType())            };             for (int i = 0; i < values.Count; i++)                seriesValuesElement.Set(i, values[i]);             SeriesValues = seriesValuesElement;        }         /// <summary>        /// Sets the values to be written to the PQDIF        /// file for the increment storage method.        /// </summary>        /// <param name="start">The start of the increment.</param>        /// <param name="count">The number of values in the series.</param>        /// <param name="increment">The amount by which to increment each value in the series.</param>        public void SetValues(object start, object count, object increment)        {            VectorElement seriesValuesElement;             seriesValuesElement = new VectorElement()            {                Size = 3,                TagOfElement = SeriesValuesTag,                TypeOfValue = PhysicalTypeExtensions.GetPhysicalType(start.GetType())            };             seriesValuesElement.Set(0, start);            seriesValuesElement.Set(1, count);            seriesValuesElement.Set(2, increment);             SeriesValues = seriesValuesElement;        }         /// <summary>        /// Indicates whether the current object is equal to another object of the same type.        /// </summary>        /// <param name="other">An object to compare with this object.</param>        /// <returns>true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.</returns>        public bool Equals(SeriesInstance other)        {            if ((object)other == null)                return false;             return ReferenceEquals(m_physicalStructure, other.m_physicalStructure);        }         /// <summary>        /// Determines whether the specified <see cref="SeriesInstance"/> is equal to the current <see cref="SeriesInstance"/>.        /// </summary>        /// <param name="obj">The object to compare with the current object. </param>        /// <returns>true if the specified object  is equal to the current object; otherwise, false.</returns>        /// <filterpriority>2</filterpriority>        public override bool Equals(object obj)        {            return Equals(obj as SeriesInstance);        }         /// <summary>        /// Serves as a hash function for a particular type.         /// </summary>        /// <returns>A hash code for the current <see cref="SeriesInstance"/>.</returns>        /// <filterpriority>2</filterpriority>        public override int GetHashCode()        {            return m_physicalStructure.GetHashCode();        }         /// <summary>        /// Gets the original data values by expanding        /// sequences and applying scale and offset.        /// </summary>        /// <returns>A list of the original data values.</returns>        private IList<object> GetOriginalValues()        {            IList<object> values = new List<object>();            VectorElement valuesVector = SeriesValues;            StorageMethods storageMethods = Definition.StorageMethodID;             bool incremented = (storageMethods & StorageMethods.Increment) != 0;             bool scaled = (storageMethods & StorageMethods.Scaled) != 0;            dynamic offset = ((object)SeriesOffset != null) ? SeriesOffset.Get() : 0;            dynamic scale = ((object)SeriesScale != null) ? SeriesScale.Get() : 1;            dynamic value;             if (!scaled)            {                offset = 0;                scale = 1;            }             if (incremented)            {                dynamic rateCount = valuesVector.Get(0);                 if (rateCount > 0)                {                    dynamic zero = rateCount - rateCount;                    dynamic one = rateCount / rateCount;                    dynamic start = zero;                     for (int i = 0; i < rateCount; i++)                    {                        int countIndex = (i * 2) + 1;                        int incrementIndex = (i * 2) + 2;                        dynamic count = valuesVector.Get(countIndex);                        dynamic increment = valuesVector.Get(incrementIndex);                         for (dynamic j = zero; j < count; j = j + one)                            values.Add((object)(start + j * increment));                         start = count * increment;                    }                }            }            else            {                for (int i = 0; i < valuesVector.Size; i++)                    values.Add(valuesVector.Get(i));            }             if (valuesVector.TypeOfValue != PhysicalType.Timestamp)            {                for (int i = 0; i < values.Count; i++)                {                    value = values[i];                    values[i] = offset + (value * scale);                }                 ApplyTransducerRatio(values);            }             return values;        }         private void ApplyTransducerRatio(IList<object> values)        {            ChannelSetting channelSetting;            double ratio;            dynamic value;             if ((object)Channel.ObservationRecord.Settings == null)                return;             if (!Channel.ObservationRecord.Settings.UseTransducer)                return;             channelSetting = Channel.Setting;             if ((object)channelSetting == null)                return;             if (!channelSetting.HasElement(ChannelSetting.XDSystemSideRatioTag))                return;             if (!channelSetting.HasElement(ChannelSetting.XDMonitorSideRatioTag))                return;             ratio = channelSetting.XDSystemSideRatio / channelSetting.XDMonitorSideRatio;             for (int i = 0; i < values.Count; i++)            {                value = values[i];                value = value * ratio;                values[i] = value;            }        }         #endregion         #region [ Static ]         // Static Fields         /// <summary>        /// Tag that identifies the scale value to apply to the series.        /// </summary>        public static readonly Guid SeriesScaleTag = new Guid("3d786f96-f76e-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the offset value to apply to the series.        /// </summary>        public static readonly Guid SeriesOffsetTag = new Guid("3d786f97-f76e-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the values contained in the series.        /// </summary>        public static readonly Guid SeriesValuesTag = new Guid("3d786f99-f76e-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the index of the channel that owns the series to be shared.        /// </summary>        public static readonly Guid SeriesShareChannelIndexTag = new Guid("8973861f-f1c3-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the index of the series to be shared.        /// </summary>        public static readonly Guid SeriesShareSeriesIndexTag = new Guid("89738620-f1c3-11cf-9d89-0080c72e70a3");         #endregion    }}