CurveGraph.h

#pragma once

#include <vector>
#include <JK2lib.h>

template<class T>
class CCurveGraph {
protected:
        // nodes
        struct GRAPH_NODE { 
                float t;                
                T         value;        

                bool operator<(const GRAPH_NODE& r_node) const
                {
                        return t < r_node.t;
                }
                bool operator>(const GRAPH_NODE& r_node) const
                {
                        return t > r_node.t;
                }
                bool operator==(const GRAPH_NODE& r_node) const
                {
                        return t == r_node.t;
                }
                bool operator<(const float& r_t) const 
                {
                        return t < r_t;
                }
                bool operator>(const float& r_t) const 
                {
                        return t > r_t;
                }
                bool operator==(const float& r_t) const 
                {
                        return t == r_t;
                }
                
        };
        

        std::vector<GRAPH_NODE> m_nodes;        

        /* 
                context pro interpolaci, zrychleni hledani klicu.
                Predpoklada se, parametr t v Interpolate postupne roste a to
                po malych skocich
        */
        size_t m_currIndex;

public:
        CCurveGraph(); 
        virtual ~CCurveGraph();

        T*              GetValue(const size_t index);
        float*  GetTime(const size_t index);

        virtual size_t AddNode(const float t, const T& value);
        size_t AddNode(const size_t index, const float t, const T& value);
        
        void DelNode(const size_t index);
                        
        void Clear();
                        
        size_t GetNodeCount() const;
        
        virtual T Interpolate(float time) = NULL;

        void Load(FileManager *f);
        void Save(FileManager *f);

        inline bool IsEnd(const float t) 
        { 
                if(!m_nodes.empty()) {
                        return t > m_nodes.back().t;
                }
                return true;
        }
        inline float GetTotalTime() 
        {
                if(!m_nodes.empty()) {
                        return m_nodes.back().t;
                }
                return 0.0f;
        }
};


#define ID_TEST(ret, l_b, h_b) if(index < l_b || index >= h_b) return ret;
#define ID_TEST_VOID(l_b, h_b) if(index < l_b || index >= h_b) return;

template<class T>
CCurveGraph<T>::CCurveGraph()
{
}
template<class T>
CCurveGraph<T>::~CCurveGraph()
{
}

template<class T> typename
T* CCurveGraph<T>::GetValue(const size_t index)
{
        ID_TEST(NULL,0, m_nodes.size());
        return &m_nodes[index].value;
}
template<class T> typename
float* CCurveGraph<T>::GetTime(const size_t index)
{
        ID_TEST(NULL,0, m_nodes.size());
        return &m_nodes[index].t;
}


template<class T> typename
size_t CCurveGraph<T>::AddNode(const float t, const T& value)
{
        GRAPH_NODE node;
        node.t = t;
        node.value = value;

        if(m_nodes.empty()) {
                m_nodes.push_back(node);
                return 0;
        }
        // najdi misto kam patri
        for(size_t i = 0; i < m_nodes.size(); i++) {
                if( node < m_nodes[i]) {
                        m_nodes.insert(m_nodes.begin() + i, node);
                        return i;                
                } else if ( i == m_nodes.size() - 1 ) {
                        m_nodes.push_back(node);
                        return m_nodes.size() - 1;
                }
        }
        return 0;
}
template<class T> typename
size_t CCurveGraph<T>::AddNode(const size_t index, const float t, const T& value)
{
        GRAPH_NODE node;
        node.t = t;
        node.value = value;

        if(index > m_nodes.size()) {
                m_nodes.push_back(node);
                return m_nodes.size() - 1;
        } else {
                m_nodes.insert(m_nodes.begin() + index, node);
                return index;
        }
        return 0;
}

template<class T>
void CCurveGraph<T>::DelNode(const size_t index)
{
        ID_TEST_VOID(0, m_nodes.size());

        m_nodes.erase(m_nodes.begin() + index);
}

template<class T>
void CCurveGraph<T>::Clear()
{
        m_nodes.clear();
}

template<class T>
size_t CCurveGraph<T>::GetNodeCount() const
{
        return m_nodes.size();
}

template<class T>
void CCurveGraph<T>::Load(FileManager *f)
{
        Clear();
        // nody
        size_t size = m_nodes.size();
        f->Get(&size);
        m_nodes.resize(size);
        for(size_t i = 0; i < size; i++) {
                f->Get(&m_nodes[i].t);
                f->Get(&m_nodes[i].value);
        }
}
template<class T>
void CCurveGraph<T>::Save(FileManager *f)
{
        // nody
        size_t size = m_nodes.size();
        f->Set(&size);
        for(size_t i = 0; i < size; i++) {
                f->Set(&m_nodes[i].t);
                f->Set(&m_nodes[i].value);
        }
}