//******************************************************************************************************//  DataPointScanner.cs - Gbtc////  Copyright © 2014, 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://  ----------------------------------------------------------------------------------------------------//  09/22/2014 - Stephen C. Wills//       Extracted from the TimeSortedDataPointScanner (now the TimeSortedArchiveFileScanner).////****************************************************************************************************** using System;using System.Collections.Generic; namespace GSF.Historian.Files{    /// <summary>    /// Scans an archive file for a given signal's data points over a given time range.    /// </summary>    internal class DataPointScanner    {        #region [ Members ]         // Fields        private readonly List<ArchiveDataBlock> m_dataBlocks;        private readonly TimeTag m_startTime;        private readonly TimeTag m_endTime;        private readonly int m_historianID;        private readonly bool m_includeStartTime;        private readonly EventHandler<EventArgs<Exception>> m_dataReadExceptionHandler;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="DataPointScanner"/> instance.        /// </summary>        /// <param name="dataBlockAllocationTable"><see cref="ArchiveFileAllocationTable"/> for the file to be scanned.</param>        /// <param name="historianID">Historian ID to scan for.</param>        /// <param name="startTime">Desired start time.</param>        /// <param name="endTime">Desired end time.</param>        /// <param name="includeStartTime">True to include data points equal to the start time; false to exclude.</param>        /// <param name="dataReadExceptionHandler">Read exception handler.</param>        public DataPointScanner(ArchiveFileAllocationTable dataBlockAllocationTable, int historianID, TimeTag startTime, TimeTag endTime, bool includeStartTime, EventHandler<EventArgs<Exception>> dataReadExceptionHandler)        {            // Find all data blocks for desired point over given time range            m_dataBlocks = dataBlockAllocationTable.FindDataBlocks(historianID, startTime, endTime, false);            m_startTime = startTime;            m_endTime = endTime;            m_historianID = historianID;            m_includeStartTime = includeStartTime;            m_dataReadExceptionHandler = dataReadExceptionHandler;        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets the historian ID associated with this <see cref="DataPointScanner"/>.        /// </summary>        public int HistorianID        {            get            {                return m_historianID;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Reads all <see cref="IDataPoint"/>s from the <see cref="ArchiveDataBlock"/>s.        /// </summary>        /// <returns>Each <see cref="IDataPoint"/> read from the <see cref="ArchiveDataBlock"/>s.</returns>        public IEnumerable<IDataPoint> Read()        {            int count = m_dataBlocks.Count;            int index = 0;             Func<IDataPoint, bool> includeDataPoint;             if (m_includeStartTime)                includeDataPoint = dataPoint => (dataPoint.Time.CompareTo(m_startTime) >= 0 && dataPoint.Time.CompareTo(m_endTime) <= 0);            else                includeDataPoint = dataPoint => (dataPoint.Time.CompareTo(m_startTime) > 0 && dataPoint.Time.CompareTo(m_endTime) <= 0);             // Loop through each data block            foreach (ArchiveDataBlock dataBlock in m_dataBlocks)            {                // Attach to data read exception event for the data block                dataBlock.DataReadException += m_dataReadExceptionHandler;                 // Pre-read all data points in this block                List<IDataPoint> dataPoints = new List<IDataPoint>();                 if (index == 0 || index == count - 1)                {                    // Read data through first and last data blocks validating time range                    foreach (IDataPoint dataPoint in dataBlock.Read())                    {                        if (includeDataPoint(dataPoint))                            dataPoints.Add(dataPoint);                    }                }                else                {                    // Read all of the data from the rest of the data blocks                    foreach (IDataPoint dataPoint in dataBlock.Read())                    {                        dataPoints.Add(dataPoint);                    }                }                 // Detach from data read exception event for the data block                dataBlock.DataReadException -= m_dataReadExceptionHandler;                 foreach (IDataPoint dataPoint in dataPoints)                {                    yield return dataPoint;                }                 index++;            }        }         #endregion    }}