fsCGraph.h

Go to the documentation of this file.

/********************************************************************
*
*       Created:        8/3/2010   9:03
*
*       File:           fsCGraph.h
*
*       Author:         Martin King
*       
*       Purpose:        Calculate variation of a couple of values
*
*********************************************************************/
 
#ifndef fsCGraphhdr
#define fsCGraphhdr
 
#include <vector>
 
#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/fsBaseTypes.h>
 
 
template <typename TValue>
class fsCGraph
{
public:
 
        void clear() { mValues.clear(); }
        void dataAdd(fsS32 pDuration, const TValue& pValue);
 
        fsS32 periodGet() const;
        TValue valueGet(fsS32 pX) const;
 
        fsCGraph()
        {
        }
 
        fsCGraph(const TValue& pInitialValue)
        {
                mValues.push_back(std::pair<fsS32, TValue>(0, pInitialValue));
        }
 
        ~fsCGraph()
        {
        }
 
protected:
 
private:
 
        std::vector<std::pair<fsS32, TValue>> mValues;
};
 
 
template <typename TValue>
void fsCGraph<TValue>::dataAdd(fsS32 pDuration, const TValue& pValue)
{
        if (mValues.empty())
        {
                fsAssert(pDuration == 0, "First value must have a duration of 0.\n");
                mValues.push_back(std::pair<fsS32, TValue>(0, pValue));
        }
        else
        {
                mValues.push_back(std::pair<fsS32, TValue>(mValues.back().first + pDuration, pValue));
        }
}
 
template <typename TValue>
fsS32 fsCGraph<TValue>::periodGet() const
{
        return mValues.back().first;
}
 
template <typename TValue>
TValue fsCGraph<TValue>::valueGet(fsS32 pX) const
{
        typename std::vector<std::pair<fsS32, TValue>>::const_iterator currVal = mValues.begin();
 
        if (pX < mValues.back().first)
        {
                while (currVal != mValues.end())
                {
                        if (pX <= (*currVal).first)
                        {
                                if (pX == (*currVal).first)
                                {
                                        return (*currVal).second;
                                }
 
                                if (mValues.begin() == currVal)
                                {
                                        return ((*currVal).second);
                                }
                                std::pair<fsS32, TValue> a(*(currVal - 1));
                                std::pair<fsS32, TValue> b(*currVal);
                                TValue ret = a.second +
                                        ((b.second - a.second) / (b.first - a.first)) * (pX - a.first);
 
                                return ret;
                        }
 
                        ++currVal;
                }
        }
        return mValues.back().second;
}
 
 
#endif