ValueTracker.h

#pragma once
#include <string>
#include <vector>

namespace ParaEngine
{

    template <class T>
    class CValueTracker
    {
    public:
        CValueTracker(void)
        {
            m_nCurrentPos = 0;
            SetSize(2); // default size is always 2
        }
        ~CValueTracker(void)
        {

        }

    public:
        void Reset()
        {
            int nSize = GetSize();
            for (int i=0;i<nSize;++i)
            {
                m_times[i] = INVALID_TIME;
            }
            m_nCurrentPos = 0;
        }
        int GetSize()
        {
            return m_nSize;
        }
        void SetSize(int nSize)
        {
            m_nSize = nSize;

            if(m_nCurrentPos<0 || m_nCurrentPos>=m_nSize)
                m_nCurrentPos = 0;
            m_times.resize(m_nSize, INVALID_TIME);
            m_values.resize(m_nSize);
        }


        void Push(int time, const T& value)
        {
            ++m_nCurrentPos;
            if(m_nCurrentPos>=m_nSize)
                m_nCurrentPos = 0;
            
            Update(time, value);
        }

        void Update(int time, const T& value)
        {
            m_times[m_nCurrentPos] = time;
            m_values[m_nCurrentPos] = value;
        }

        int GetTime(int nPos=0)
        {
            nPos = m_nCurrentPos+nPos;
            if(nPos<0)
            {
                nPos += m_nSize;
                if(nPos>=0)
                    return m_times[nPos];
            }
            else if(nPos>=m_nSize)
            {
                nPos -= m_nSize;
                if(nPos>=0)
                    return m_times[nPos];
            }
            else
            {
                return m_times[nPos];
            }
            return INVALID_TIME;
        }

        const T& GetValue(int nPos=0)
        {
            nPos = m_nCurrentPos+nPos;
            if(nPos<0)
            {
                nPos += m_nSize;
                if(nPos>=0)
                    return m_values[nPos];
            }
            else if(nPos>=m_nSize)
            {
                nPos -= m_nSize;
                if(nPos>=0)
                    return m_values[nPos];
            }
            else
            {
                return m_values[nPos];
            }
            // this should never be called
            static T g_empty;
            return g_empty;
        }
        bool GetValue(T& value, int nPos)
        {
            if(GetTime(nPos) == INVALID_TIME)
                return false;
            nPos = m_nCurrentPos+nPos;
            if(nPos<0)
            {
                nPos += m_nSize;
                if(nPos>=0)
                {
                    value = m_values[nPos];
                    return true;
                }
            }
            else if(nPos>=m_nSize)
            {
                nPos -= m_nSize;
                if(nPos>=0)
                {
                    value = m_values[nPos];
                    return true;
                }
            }
            else
            {
                value = m_values[nPos];
                return true;
            }
            // no value is found
            return false;
        }

        
        BOOL CompareWith(const T& right)
        {
            if(m_times[m_nCurrentPos] == INVALID_TIME)
                return false;
            return (m_values[m_nCurrentPos] == right);
        }

        bool IsConstant()
        {
            bool bFirstValue = true;
            bool bConstant = false;
            T lastValue;
            for (int i=0;i<m_nSize;++i)
            {
                if( m_times[i] != INVALID_TIME)
                {
                    if(bFirstValue)
                    {
                        lastValue = m_values[i];
                        bConstant = true;
                        bFirstValue = false;
                    }
                    else
                    {
                        if(lastValue != m_values[i])
                            return false;
                    }
                }
                else
                    return false;
            }
            return bConstant;
        }

    private:
        vector <int> m_times;
        vector <T> m_values;
        int m_nCurrentPos;
        int m_nSize;
        static const int INVALID_TIME = -1;
    };

    class CNetByteArray: public std::vector<byte>
    {
    public:
        bool operator == (const CNetByteArray& right)
        {
            return EqualsTo(&(right[0]), (int)right.size());
        }

        void SetData(const byte* pData, int nSize)
        {
            this->resize(nSize);
            if(nSize>0)
            {
                memcpy(&((*this)[0]), pData, nSize);
            }
        }

        CNetByteArray& operator = (const CNetByteArray& right)
        {
            SetData(&(right[0]), (int)right.size());
            return *this;
        }

        bool EqualsTo(const byte* pData, int nSize)
        {
            if((int)(this->size()) ==  nSize)
            {
                int i=0;
                for (;i<nSize && ((*this)[i]==pData[i]);++i)
                {
                }
                return (i==nSize);
            }
            else
                return false;
        }
    };

    typedef CValueTracker<Vector3> CVector3Tracker;
    typedef CValueTracker<int> CIntTracker;
    typedef CValueTracker<float> CFloatTracker;
    typedef CValueTracker<std::string> CStringTracker;
    typedef CValueTracker<bool> CBooleanTracker;
    typedef CValueTracker<CNetByteArray> CNetByteArrayTracker;
}