TAPsCircularCounter.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsCircularCounter.hpp

GraphNode class is a base class for a graph node.

SUKITTI PUNAK   (04/17/2008)
UPDATE          (04/17/2008)
******************************************************************************/
#ifndef TAPs_CIRCULAR_COUNTER_HPP
#define TAPs_CIRCULAR_COUNTER_HPP

#include "../Core/TAPsLib.hpp"

BEGIN_NAMESPACE_TAPs
//=============================================================================

template <typename T>
class CircularCounter {
//=============================================================================
// Member Functions
public:
    //-------------------------------------------------------------------------
    // Output Operator <<
    friend std::ostream & operator<< ( std::ostream &output, CircularCounter<T> const &ctr )
    {
        output  << "CircularCounter<" << typeid(T).name() << ">"
                <<  " Highest Value (" << ctr.m_tHighest
                << ") Current Value (" << ctr.m_tCurrent
                << ") Lowest Value ("  << ctr.m_tLowest;
                << ")\n";
        return output;
    }
    //-------------------------------------------------------------------------
    // Constructor and Destructor
public:

    CircularCounter () : m_tCurrent(0)
    {
        if ( typeid(T) == typeid(unsigned char) ) {
            m_tLowest   = 0;
            m_tHighest  = static_cast<unsigned char>( UCHAR_MAX );
        }
        else if ( typeid(T) == typeid(char) ) {
            m_tLowest   = static_cast<char>( CHAR_MIN );
            m_tHighest  = static_cast<char>( CHAR_MAX );
        }
        else if ( typeid(T) == typeid(unsigned short) ) {
            m_tLowest   = 0;
            m_tHighest  = static_cast<unsigned short>( USHRT_MAX );
        }
        else if ( typeid(T) == typeid(short) ) {
            m_tLowest   = static_cast<short>( SHRT_MIN );
            m_tHighest  = static_cast<short>( SHRT_MAX );
        }
        else if ( typeid(T) == typeid(unsigned int) ) {
            m_tLowest   = 0;
            m_tHighest  = static_cast<unsigned int>( UINT_MAX );
        }
        else if ( typeid(T) == typeid(int) ) {
            m_tLowest   = static_cast<int>( INT_MIN );
            m_tHighest  = static_cast<int>( INT_MAX );
        }
        else if ( typeid(T) == typeid(unsigned long) ) {
            m_tLowest   = 0;
            m_tHighest  = static_cast<unsigned long>( ULONG_MAX );
        }
        else if ( typeid(T) == typeid(long) ) {
            m_tLowest   = static_cast<long>( LONG_MIN );
            m_tHighest  = static_cast<long>( LONG_MAX );
        }
    }

    CircularCounter ( T v1, T v2, T v3 )
    {
        if ( v1 >= v2 ) {
            if ( v1 >= v3 ) {
                m_tHighest = v1;
                if ( v2 >= v3 ) {
                    m_tCurrent = v2;
                    m_tLowest  = v3;
                }
                else {
                    m_tCurrent = v3;
                    m_tLowest  = v2;
                }
            }
            else {
                m_tHighest = v3;
                m_tCurrent = v1;
                m_tLowest  = v2;
            }
        }
        else {
            if ( v2 >= v3 ) {
                m_tHighest = v2;
                if ( v1 >= v3 ) {
                    m_tCurrent = v1;
                    m_tLowest  = v3;
                }
                else {
                    m_tCurrent = v3;
                    m_tLowe st = v1;
                }
            }
            else {
                m_tHighest = v3;
                m_tCurrent = v2;
                m_tLowe st = v1;
            }
        }
    }

    virtual ~CircularCounter () {};

    //-------------------------------------------------------------------------
    // Get/Set Fn(s)
    inline T    GetValueLowest  () const { return m_tLowest; }
    inline T    GetValueCurrent () const { return m_tCurrent; }
    inline T    GetValueHighest () const { return m_tHighest; }
    inline void SetValueLowest  ( T v ) 
    {
        if ( m_tLowest < m_tHighest )   m_tLowest  = v;
        if ( m_tLowest > m_tCurrent )   m_tCurrent = v;
    }
    inline void SetValueCurrent ( T v )
    {
        if      ( v > m_tHighest )  m_tCurrent = m_tHighest;
        else if ( v < m_tLowest )   m_tCurrent = m_tLowest;
        else                        m_tCurrent = v;
    }
    inline void SetValueHighest ( T v )
    {
        if ( m_tHighest > m_tLowest )   m_tHighest = v;
        if ( m_tHighest < m_tCurrent )  m_tCurrent = v;
    }

    //-------------------------------------------------------------------------
    // Operations

    inline void CountUp ()
    {
        ++m_tCurrent;
        CheckCountUp();
    }
    inline void CountUp ( T v )
    {
        m_tCurrent += v;
        CheckCountUp();
    }
    inline void CountDown ()
    {
        --m_tCurrent;
        CheckCountDown();
    }
    inline void CountDown ( T v )
    {
        m_tCurrent -= v;
        CheckCountDown();
    }

    inline T CountUpAndReturnTheCountValue ()
    {
        ++m_tCurrent;
        CheckCountUp();
        return m_tCurrent;
    }
    inline T CountUpAndReturnTheCountValue ( T v )
    {
        m_tCurrent += v;
        CheckCountUp();
        return m_tCurrent;
    }
    inline T CountDownAndReturnTheCountValue ()
    {
        --m_tCurrent;
        CheckCountDown();
        return m_tCurrent;
    }
    inline T CountDownAndReturnTheCountValue ( T v )
    {
        m_tCurrent -= v;
        CheckCountDown();
        return m_tCurrent;
    }

//============================================================================
protected:
// Helper Function(s)
    inline void CheckCountUp ()
    { if ( m_tCurrent > m_tHighest )    m_tCurrent = m_tLowest; }
    inline void CheckCountDown ()
    { if ( m_tCurrent < m_tLowest )     m_tCurrent = m_tHighest; }

// Data Members
    T   m_tLowest;
    T   m_tCurrent;
    T   m_tHighest;
//============================================================================
#if defined(__gl_h_) || defined(__GL_H__)
public:
    // DrawByOpenGL UNFINISHED!!!
    virtual void DrawByOpenGL () {};
#endif
}; // END CLASS CircularCounter
//=============================================================================
//-----------------------------------------------------------------------------
// Define CircularCounters
typedef CircularCounter<unsigned char>  CircularCounteruc;
typedef CircularCounter<char>           CircularCounterc;
typedef CircularCounter<unsigned short> CircularCounterus;
typedef CircularCounter<short>          CircularCounters;
typedef CircularCounter<unsigned int>   CircularCounterui;
typedef CircularCounter<int>            CircularCounteri;
typedef CircularCounter<unsigned long>  CircularCounterul;
typedef CircularCounter<long>           CircularCounterl;
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    //#include "TAPsCircularCounter.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----