//******************************************************************************************************//  ChannelInstance.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 System.Linq;using System.Text;using GSF.PQDIF.Physical; namespace GSF.PQDIF.Logical{    /// <summary>    /// Represents a channel instance in a PQDIF file. See IEEE 1159.3-2019 section 5.4.3    /// for details. A channel instance resides in an <see cref="ObservationRecord"/>, and     /// is defined by a <see cref="ChannelDefinition"/> inside the observation record's    /// <see cref="DataSourceRecord"/>.    /// </summary>    public class ChannelInstance : IEquatable<ChannelInstance>    {        #region [ Members ]         // Fields        private readonly CollectionElement m_physicalStructure;        private readonly ObservationRecord m_observationRecord;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new instance of the <see cref="ChannelInstance"/> class.        /// </summary>        /// <param name="physicalStructure">The collection element which is the physical structure of the channel instance.</param>        /// <param name="observationRecord">The observation record in which the channel instance resides.</param>        public ChannelInstance(CollectionElement physicalStructure, ObservationRecord observationRecord)        {            m_physicalStructure = physicalStructure;            m_observationRecord = observationRecord;        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets the physical structure of the channel instance.        /// </summary>        public CollectionElement PhysicalStructure        {            get            {                return m_physicalStructure;            }        }         /// <summary>        /// Gets the observation record in which the channel instance resides.        /// </summary>        public ObservationRecord ObservationRecord        {            get            {                return m_observationRecord;            }        }         /// <summary>        /// Gets the channel definition which defines the channel instance.        /// </summary>        public ChannelDefinition Definition        {            get            {                return m_observationRecord.DataSource.ChannelDefinitions[(int)ChannelDefinitionIndex];            }        }         /// <summary>        /// Gets the channel setting which defines the instrument settings for the channel.        /// </summary>        public ChannelSetting Setting        {            get            {                MonitorSettingsRecord monitorSettings;                IList<ChannelSetting> channelSettings;                 monitorSettings = m_observationRecord.Settings;                 if ((object)monitorSettings == null)                    return null;                 channelSettings = monitorSettings.ChannelSettings;                 if ((object)channelSettings == null)                    return null;                 return channelSettings.FirstOrDefault(channelSetting => channelSetting.ChannelDefinitionIndex == ChannelDefinitionIndex);            }        }         /// <summary>        /// Gets the index of the <see cref="ChannelDefinition"/>        /// which defines the channel instance.        /// </summary>        public uint ChannelDefinitionIndex        {            get            {                return m_physicalStructure                    .GetScalarByTag(ChannelDefinition.ChannelDefinitionIndexTag)                    .GetUInt4();            }            set            {                ScalarElement channelDefinitionIndexElement = m_physicalStructure.GetOrAddScalar(ChannelDefinition.ChannelDefinitionIndexTag);                channelDefinitionIndexElement.TypeOfValue = PhysicalType.UnsignedInteger4;                channelDefinitionIndexElement.SetUInt4(value);            }        }         /// <summary>        /// Gets the identifier for the harmonic or        /// interharmonic group represented by this channel.        /// </summary>        public short ChannelGroupID        {            get            {                ScalarElement channelGroupIDElement = m_physicalStructure.GetScalarByTag(ChannelGroupIDTag);                 if ((object)channelGroupIDElement == null)                    return 0;                 return channelGroupIDElement.GetInt2();            }            set            {                ScalarElement channelGroupIDElement = m_physicalStructure.GetOrAddScalar(ChannelGroupIDTag);                channelGroupIDElement.TypeOfValue = PhysicalType.Integer2;                channelGroupIDElement.SetInt2(value);            }        }         /// <summary>        /// Gets the name of the of a device specific code or hardware        /// module, algorithm, or rule not necessarily channel based        /// that cause this channel to be recorded.        /// </summary>        public string TriggerModuleName        {            get            {                VectorElement moduleNameElement = m_physicalStructure.GetVectorByTag(ChannelTriggerModuleNameTag);                 if ((object)moduleNameElement == null)                    return null;                 return Encoding.ASCII.GetString(moduleNameElement.GetValues()).Trim((char)0);            }            set            {                byte[] bytes = Encoding.ASCII.GetBytes(value + (char)0);                m_physicalStructure.AddOrUpdateVector(ChannelTriggerModuleNameTag, PhysicalType.Char1, bytes);            }        }         /// <summary>        /// Gets the name of the device involved in        /// an external cross trigger scenario.        /// </summary>        public string CrossTriggerDeviceName        {            get            {                VectorElement deviceNameElement = m_physicalStructure.GetVectorByTag(CrossTriggerDeviceNameTag);                 if ((object)deviceNameElement == null)                    return null;                 return Encoding.ASCII.GetString(deviceNameElement.GetValues()).Trim((char)0);            }            set            {                byte[] bytes = Encoding.ASCII.GetBytes(value + (char)0);                m_physicalStructure.AddOrUpdateVector(CrossTriggerDeviceNameTag, PhysicalType.Char1, bytes);            }        }         /// <summary>        /// Gets the series instances contained in this channel.        /// </summary>        public IList<SeriesInstance> SeriesInstances        {            get            {                return m_physicalStructure                    .GetCollectionByTag(SeriesInstancesTag)                    .GetElementsByTag(OneSeriesInstanceTag)                    .Cast<CollectionElement>()                    .Zip(Definition.SeriesDefinitions, (collection, seriesDefinition) => new SeriesInstance(collection, this, seriesDefinition))                    .ToList();            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Adds a new series instance to the collection        /// of series instances in this channel instance.        /// </summary>        public SeriesInstance AddNewSeriesInstance()        {            if (Definition.SeriesDefinitions.Count <= SeriesInstances.Count)                throw new InvalidOperationException("Cannot create a series instance without a corresponding series definition.");             CollectionElement seriesInstanceElement = new CollectionElement() { TagOfElement = OneSeriesInstanceTag };            SeriesDefinition seriesDefinition = Definition.SeriesDefinitions[SeriesInstances.Count];            SeriesInstance seriesInstance = new SeriesInstance(seriesInstanceElement, this, seriesDefinition);            seriesInstanceElement.AddOrUpdateVector(SeriesInstance.SeriesValuesTag, PhysicalType.UnsignedInteger1, new byte[0]);             CollectionElement seriesInstancesElement = m_physicalStructure.GetCollectionByTag(SeriesInstancesTag);             if ((object)seriesInstancesElement == null)            {                seriesInstancesElement = new CollectionElement() { TagOfElement = SeriesInstancesTag };                m_physicalStructure.AddElement(seriesInstancesElement);            }             seriesInstancesElement.AddElement(seriesInstanceElement);             return seriesInstance;        }         /// <summary>        /// Removes the given series instance from the collection of series instances.        /// </summary>        /// <param name="seriesInstance">The series instance to be removed.</param>        public void Remove(SeriesInstance seriesInstance)        {            CollectionElement seriesInstancesElement;            List<CollectionElement> seriesInstanceElements;            IList<SeriesDefinition> seriesDefinitions;            SeriesInstance instance;             seriesInstancesElement = m_physicalStructure.GetCollectionByTag(SeriesInstancesTag);             if ((object)seriesInstancesElement == null)                return;             seriesDefinitions = Definition.SeriesDefinitions;            seriesInstanceElements = seriesInstancesElement.GetElementsByTag(OneSeriesInstanceTag).Cast<CollectionElement>().ToList();             for (int i = seriesInstanceElements.Count; i >= 0; i--)            {                instance = new SeriesInstance(seriesInstanceElements[i], this, seriesDefinitions[i]);                 if (Equals(seriesInstance, instance))                    seriesInstancesElement.RemoveElement(seriesInstancesElement);            }        }         /// <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(ChannelInstance other)        {            if ((object)other == null)                return false;             return ReferenceEquals(m_physicalStructure, other.m_physicalStructure);        }         /// <summary>        /// Determines whether the specified <see cref="ChannelInstance"/> is equal to the current <see cref="ChannelInstance"/>.        /// </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 ChannelInstance);        }         /// <summary>        /// Serves as a hash function for a particular type.         /// </summary>        /// <returns>A hash code for the current <see cref="ChannelInstance"/>.</returns>        /// <filterpriority>2</filterpriority>        public override int GetHashCode()        {            return m_physicalStructure.GetHashCode();        }         #endregion         #region [ Static ]         // Static Fields         /// <summary>        /// Tag that identifies the channel group ID.        /// </summary>        public static readonly Guid ChannelGroupIDTag = new Guid("f90de218-e67b-4cf1-a295-b021a2d46767");         /// <summary>        /// Tag that identifies the series instances collection.        /// </summary>        public static readonly Guid SeriesInstancesTag = new Guid("3d786f93-f76e-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies a single series instance in the collection.        /// </summary>        public static readonly Guid OneSeriesInstanceTag = new Guid("3d786f94-f76e-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the channel trigger module name.        /// </summary>        public static readonly Guid ChannelTriggerModuleNameTag = new Guid("0fa118c6-cb4a-11cf-9d89-0080c72e70a3");         /// <summary>        /// Tag that identifies the cross trigger device name.        /// </summary>        public static readonly Guid CrossTriggerDeviceNameTag = new Guid("0fa118c5-cb4a-11cf-9d89-0080c72e70a3");         #endregion    }}