TnbRange.h

[詳解]

#pragma once
#include "TnbSerializer.h"
#include "TnbComparable.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, typename DIF=TYP>
class CRangeT : public IComparableT< TNB::CRangeT<TYP,DIF> >, public ISerializable 
{
    TYP     m_first;    
    TYP     m_last;     
 
    void m_CheckRange(void)
    {
        if ( m_first > m_last )
        {
            Swap(m_first, m_last);
            ASSERTLIB(m_first <= m_last);
        }
    }
 
public:
 
    CRangeT(const TYP& t = TYP()) : m_first(t), m_last(t) 
    {
    }
 
    CRangeT(const TYP& t1, const TYP& t2) : m_first(t1), m_last(t2)
    {
        m_CheckRange();
    }
 
    CRangeT(const CRangeT& other) : m_first(other.m_first), m_last(other.m_last)
    {
        ASSERTLIB(m_first <= m_last);
    }
 
    CRangeT& operator=(const CRangeT& other)
    {
        m_first = other.m_first;
        m_last  = other.m_last;
        ASSERTLIB(m_first <= m_last);
        return *this;
    }
 
    void Set(const TYP& t1, const TYP& t2)
    {
        m_first = t1;
        m_last  = t2;
        m_CheckRange();
    }
 
    void SetFirst(const TYP& t)
    {
        m_first = t;
        m_CheckRange();
    }
 
    void SetLast(const TYP& t)
    {
        m_first = t;
        m_CheckRange();
    }
 
    void SetRange(const DIF& d)
    {
        m_last = m_first + d;
        m_CheckRange();
    }
 
    TYP GetFirst(void)
    {
        return m_first;
    }
 
    const TYP& GetFirst(void) const
    {
        return m_first;
    }
 
    TYP GetLast(void)
    {
        return m_last;
    }
 
    const TYP& GetLast(void) const
    {
        return m_last;
    }
 
    DIF Difference(void) const
    {
        return m_last - m_first;
    }
 
    TYP Center(void) const
    {
        TYP r = m_first;
        return r += (Difference() / 2);
    }
 
    CRangeT& operator+=(const DIF& dif)
    {
        m_first += dif;
        m_last  += dif;
        m_CheckRange();
        return *this;
    }
 
    inline friend CRangeT operator+(const CRangeT& rng, const DIF& dif)
    {
        CRangeT r = rng;
        return r += dif;
    }
 
    CRangeT& operator-=(const DIF& dif)
    {
        m_first -= dif;
        m_last  -= dif;
        m_CheckRange();
        return *this;
    }
 
    inline friend CRangeT operator-(const CRangeT& rng, const DIF& dif)
    {
        CRangeT r = rng;
        return r -= dif;
    }
 
    bool IsInRange(const TYP& t) const
    {
        return m_first <= t && m_last >= t;
    }
 
    bool IsInRange(const CRangeT& rng) const
    {
        return m_first <= rng.m_first && m_last >= rng.m_last;
    }
 
    bool InRange(const TYP& t) const
    {
        return IsInRange(t);
    }
 
    bool InRange(const CRangeT& rng) const
    {
        return IsInRange(rng);
    }
 
    enum ERelationType
    {
        UNRELATED,  
        TOUCHED,    
        WARPPED     
    };
 
    ERelationType GetRelation(const CRangeT& rng) const
    {
        CRangeT r1 = *this;
        CRangeT r2 = rng;
        if ( *this > rng )
        {
            r1 = rng;
            r2 = *this;
        }
        if ( r1.m_last >= r2.m_last )
        {
            return WARPPED;
        }
        if ( r1.m_last >= r2.m_first )
        {
            if ( r1.m_first == r2.m_first )
            {
                return WARPPED;
            }
            return TOUCHED;
        }
        return UNRELATED;
    }
 
    CRangeT Intersect(const CRangeT& rng) const
    {
        CRangeT r1 = *this;
        CRangeT r2 = rng;
        if ( *this > rng )
        {
            r1 = rng;
            r2 = *this;
        }
        ERelationType rt = r1.GetRelation(r2);
        if ( rt == UNRELATED )
        {
            throw CEmptyException(); //無関係。重なっている部分はありません。
        }
        else if ( rt == WARPPED )
        {
            //内包。片方が全て含んでいます。
            if ( r1.m_first == r2.m_first )
            {
                return r1;
            }
            return r2;
        }
        return CRangeT(r2.m_first, r1.m_last);
    }
 
    CRangeT Union(const CRangeT& rng) const
    {
        TYP t1 = min(m_first, rng.m_first);
        TYP t2 = max(m_last, rng.m_last);
        return CRangeT(t1, t2);
    }
 
    virtual INT_PTR Compare(const CRangeT& rng) const
    {
        INT_PTR r = IComparatorT<TYP>::GetDefault().CompareTo(m_first, rng.m_first);
        return (r != 0) ? r : IComparatorT<TYP>::GetDefault().CompareTo(m_last, rng.m_last);
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        _sr << m_first << m_last;
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        ds >> m_first >> m_last;
    }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")