cGraphData.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_GraphData_H
#define _INC_GraphData_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif 
 
#include "CGraphCfg.h"
#include "GrayCore/include/cFileText.h"
 
namespace GrayGraph
{
        class CGraphPoint
        {
 
        public:
                GraphTime_t m_time;             
                GraphVal_t m_val;               
 
        public:
                CGraphPoint()
                        : m_val(0)
                        , m_time(0)
                {
                }
                CGraphPoint(GraphVal_t val, CGraphTime time)
                        : m_val(val)
                        , m_time(CVT_TIME_TO_BASE(time))
                {
                }
        };
 
        class GRAYGRAPH_LINK CGraphStats
        {
        public:
                GraphVal_t m_valMin;
                GraphVal_t m_valMax;
                GraphVal_t m_valAvg;    // Stats for the block.
 
        public:
                virtual ITERATE_t get_PointQty() const = 0;
 
                GraphVal_t get_ValMin() const
                {
                        ASSERT(get_PointQty());
                        return m_valMin;
                }
                GraphVal_t get_ValMax() const
                {
                        ASSERT(get_PointQty());
                        return m_valMax;
                }
                GraphVal_t get_ValAvg() const
                {
                        ASSERT(get_PointQty());
                        return m_valAvg;
                }
        };
 
        class GRAYGRAPH_LINK CGraphBlock : public CGraphStats
        {
        private:
                CArray <CGraphPoint, CGraphPoint&> m_aPoints;   // Time sorted array of values to graph.
        private:
                void Copy(const CGraphBlock& block);
                void RecalcStats();
        public:
                CGraphBlock& operator = (const CGraphBlock & block)
                {
                        m_aPoints.RemoveAll();
                        Copy(block);
                        return *this;
                }
 
                virtual ITERATE_t get_PointQty() const override
                {
                        return(m_aPoints.GetSize());
                }
 
                CGraphPoint* GetPointPtr(ITERATE_t i)
                {
                        //ASSERT(i<get_PointQty());
                        return(&(m_aPoints.ElementAt(i)));
                }
                const CGraphPoint* GetPoint(ITERATE_t i) const
                {
                        //ASSERT(i<get_PointQty());
                        return(&(const_cast <CGraphBlock*>(this)->m_aPoints.ElementAt(i)));
                }
                GraphVal_t GetPointVal(ITERATE_t i) const
                {
                        //ASSERT(i<get_PointQty());
                        return(GetPoint(i)->m_val);
                }
                CGraphTime GetPointTime(ITERATE_t i) const
                {
                        //ASSERT(i<get_PointQty());
                        return(GetPoint(i)->m_time);
                }
 
                void Decimate();
                ITERATE_t FindPointIndexForTime(CGraphTime timeVal, COMPARE_t& iCompare) const;
 
                CGraphTime get_TimeFirst() const
                {
                        ASSERT(get_PointQty());
                        return(GetPointTime(0));
                }
                CGraphTime get_TimeLast() const
                {
                        ASSERT(get_PointQty());
                        return(GetPointTime(get_PointQty() - 1));
                }
 
                ITERATE_t AddPoint(GraphVal_t iVal, CGraphTime time);
                ITERATE_t AddPoints(CGraphTime timestart, const GraphVal_t* piVal, ITERATE_t iQty, int iTimeInterval);
 
                void SplitBlock(CGraphBlock* pBlockOld, CGraphTime timeVal);
 
                CGraphBlock();
                CGraphBlock(const CGraphBlock& block);  // copy constructor
                ~CGraphBlock();
        };
 
        class GRAYGRAPH_LINK CGraphData : public CGraphStats
        {
        private:
                ITERATE_t m_iPointQty; 
 
                // Store data in blocks.
                CArray<CGraphBlock, CGraphBlock&> m_Blocks;
 
                // Operations
        private:
                ITERATE_t get_BlockQty() const
                {
                        return(m_Blocks.GetSize());
                }
                const CGraphBlock* GetBlock(ITERATE_t i) const
                {
                        // MFC CArray has the annoying habit of copying referenced objects unless const.
                        return(&(const_cast<CGraphData*>(this)->m_Blocks.ElementAt(i)));
                }
 
                ITERATE_t FindBlockForTime(CGraphTime timeVal, COMPARE_t& iCompare, ITERATE_t& iBlock) const;
                void RecalcStats();
 
        public:
                // void SetTimeGapSize( cTimeSpan iTimeGapSize );
                CGraphData();
                ~CGraphData();
 
                virtual ITERATE_t get_PointQty() const override
                {
                        return(m_iPointQty);
                }
 
                CGraphTime get_TimeFirst() const
                {
                        ASSERT(get_PointQty());
                        return(GetBlock(0)->get_TimeFirst());
                }
                CGraphTime get_TimeLast() const
                {
                        ASSERT(get_PointQty());
                        return(GetBlock(get_BlockQty() - 1)->get_TimeLast());
                }
 
                bool GetBoundRect(CGraphRect& rectBound) const
                {
                        if (get_PointQty() == 0)
                                return false;
                        rectBound.left = (GraphVal_t)CVT_TIME_TO_BASE(get_TimeFirst());
                        rectBound.right = (GraphVal_t)CVT_TIME_TO_BASE(get_TimeLast());
                        rectBound.top = get_ValMin();
                        rectBound.bottom = get_ValMax();
                        return true;
                }
 
                ITERATE_t FindPointIndexForTime(CGraphTime timeVal, COMPARE_t& iCompare) const;
                const CGraphPoint* GetPoint(ITERATE_t i) const;
 
                ITERATE_t AddPoint(GraphVal_t iVal, CGraphTime time);
                ITERATE_t AddPoints(CGraphTime timestart, const GraphVal_t* piVal, ITERATE_t iQty, int iTimeInterval);
 
                ITERATE_t ExportFileBin(CFile& File, CGraphTime timeStart, CGraphTime timeStop);
                ITERATE_t ExportFileText(CStdioFile& File, CGraphTime timeStart, CGraphTime timeStop);
                ITERATE_t ImportFileBin(CFile& File);
                ITERATE_t ImportFileText(CStdioFile& File);
        };
};
 
#endif // !defined(_INC_GraphData_H)