cPair.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPair_H
#define _INC_cPair_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cMem.h"
#include "cDebugAssert.h"
 
namespace Gray
{
        template<typename TYPE>
        class cRangeT
        {
                typedef cRangeT<TYPE> THIS_t;
 
        public:
                TYPE m_Lo;              
                TYPE m_Hi;              
        public:
                TYPE get_Min() const
                {
                        return m_Lo;
                }
                TYPE get_Max() const
                {
                        return m_Hi;
                }
                TYPE get_Avg() const
                {
                        return (m_Lo + m_Hi) / 2;
                }
                TYPE GetClampValue(TYPE nVal) const
                {
                        // assume normalized.
                        if (nVal < m_Lo)
                                return m_Lo;
                        if (nVal > m_Hi)
                                return m_Hi;
                        return nVal;
                }
                bool IsInsideI(TYPE nVal) const
                {
                        // assume normalized.
                        return nVal >= m_Lo && nVal <= m_Hi;
                }
                bool IsInsideX(TYPE nVal) const
                {
                        // assume normalized.
                        return nVal >= m_Lo && nVal < m_Hi;
                }
 
                TYPE get_RangeI() const
                {
                        // assume normalized.
                        return (m_Hi - m_Lo) + 1;       // inclusive. integer
                }
                TYPE get_RangeX() const
                {
                        // assume normalized.
                        return m_Hi - m_Lo;     // exclusive.
                }
 
                TYPE GetLinear1(float fOne) const
                {
                        return (TYPE)(m_Lo + (fOne * get_RangeI()));
                }
                int GetSpinValueI(int iVal) const
                {
                        iVal -= (int)m_Lo;
                        int iRange = (int)get_RangeI();
                        iVal %= iRange;
                        if (iVal < 0)
                                iVal += (int)(m_Hi + 1);
                        else
                                iVal += (int)(m_Lo);
#ifdef _DEBUG
                        TYPE iValClamp = (TYPE)GetClampValue((TYPE)iVal);
                        ASSERT(iVal == iValClamp);
#endif
                        return iVal;
                }
 
                // Setters.
                void SetZero()
                {
                        m_Hi = m_Lo = 0;
                }
                void put_Min(TYPE iLo)
                {
                        m_Lo = iLo;
                }
                void put_Max(TYPE iHi)
                {
                        m_Hi = iHi;
                }
                void SetRange(TYPE iLo, TYPE iHi)
                {
                        m_Lo = iLo;
                        m_Hi = iHi;
                }
                void NormalizeRange()
                {
                        if (m_Lo > m_Hi)
                        {
                                cValT::Swap<TYPE>(m_Lo, m_Hi);
                        }
                }
                void UnionValue(TYPE nVal)
                {
                        if (nVal < m_Lo)
                                m_Lo = nVal;
                        if (nVal > m_Hi)
                                m_Hi = nVal;
                }
 
                bool IsRangeOverlapI(const THIS_t& x) const
                {
                        // Do 2 ranges (assume Normalized/proper ordered ranges) overlap ?
                        if (x.m_Lo > m_Hi)
                                return false;
                        if (x.m_Hi < m_Lo)
                                return false;
                        return true;
                }
                void SetUnionRange(const THIS_t& x)
                {
                        // assume Normalized/proper ordered ranges
                        if (x.m_Hi > m_Hi)
                        {
                                m_Hi = x.m_Hi;
                        }
                        if (x.m_Lo < m_Lo)
                        {
                                m_Lo = x.m_Lo;
                        }
                }
        };
 
        template< class _TYPE_A, class _TYPE_B >
        class cPairT
        {
 
        public:
                _TYPE_A m_a;    
                _TYPE_B m_b;    
 
        public:
                _TYPE_A get_A() const noexcept
                {
                        return this->m_a;       // Key
                }
                _TYPE_B get_B() const noexcept
                {
                        return this->m_b;       // Value
                }
                _TYPE_A get_HashCode() const noexcept
                {
                        return m_a;
                }
 
                void put_A(_TYPE_A a) noexcept
                {
                        m_a = a;
                }
                void put_B(_TYPE_B b) noexcept
                {
                        m_b = b;
                }
        };
 
        template< class _TYPE_A, class _TYPE_ARG_A, class _TYPE_B, class _TYPE_ARG_B >
        class cPairX : public cPairT < _TYPE_A, _TYPE_B >
        {
 
                typedef cPairT<_TYPE_A, _TYPE_B> SUPER_t;
 
        public:
                cPairX() noexcept       // Undefined values for dynamic arrays.
                {}
                cPairX(_TYPE_ARG_A a, _TYPE_ARG_B b) noexcept
                {
                        this->m_a = a;
                        this->m_b = b;
                }
 
                void SetValues(_TYPE_ARG_A a, _TYPE_ARG_B b) noexcept
                {
                        this->m_a = a;
                        this->m_b = b;
                }
                _TYPE_ARG_A get_HashCode() const noexcept
                {
                        return this->m_a;
                }
                const _TYPE_A& get_A() const noexcept
                {
                        return this->m_a;
                }
                void put_A(_TYPE_ARG_A a) noexcept
                {
                        this->m_a = a;
                }
                const _TYPE_A& get_B() const noexcept
                {
                        return this->m_b;
                }
                void put_B(_TYPE_ARG_B b) noexcept
                {
                        this->m_b = b;
                }
        };
 
        template< class _TYPE_A, class _TYPE_B >
        class cPair : public cPairT < _TYPE_A, _TYPE_B >
        {
 
                typedef cPairT<_TYPE_A, _TYPE_B> SUPER_t;
 
        public:
                cPair() noexcept // Undefined values for dynamic arrays.
                {}
                cPair(_TYPE_A a, _TYPE_B b) noexcept
                {
                        this->m_a = a;
                        this->m_b = b;
                }
 
                // If element is a member of a static array.
 
                bool IsValidIndex(ITERATE_t i) const noexcept
                {
                        if (i < 0)
                                return false;
                        return this[i].m_a || this[i].m_b;
                }
 
                ITERATE_t FindIA(_TYPE_A a) const noexcept
                {
                        for (ITERATE_t i = 0; IsValidIndex(i); i++)
                        {
                                if (this[i].m_a == a)
                                        return i;
                        }
                        return k_ITERATE_BAD;
                }
                ITERATE_t FindIB(_TYPE_B b) const noexcept
                {
                        for (ITERATE_t i = 0; IsValidIndex(i); i++)
                        {
                                if (this[i].m_b == b)
                                        return i;
                        }
                        return k_ITERATE_BAD;
                }
                 
                bool FindARetB(_TYPE_A a, _TYPE_B* pb) const noexcept
                {
                        ITERATE_t i = FindIA(a);
                        if (i >= 0)
                        {
                                *pb = this[i].m_b;
                                return true;
                        }
                        return false;
                }
                bool FindBRetA(_TYPE_B b, _TYPE_A* pa) const noexcept
                {
                        ITERATE_t i = FindIB(b);
                        if (i >= 0)
                        {
                                *pa = this[i].m_a;
                                return true;
                        }
                        return false;
                }
 
                _TYPE_B FindSortedARetB(_TYPE_A a) const noexcept
                {
                        ITERATE_t i = 0;
                        for (; IsValidIndex(i); i++)
                        {
                                if (a < this[i + 1].m_a)
                                        return(this[i].m_b);
                        }
                        return(this[i - 1].m_b);
                }
        };
};
#endif // _INC_cPair_H