TnbNullable.h

[詳解]

#pragma once
#include "TnbSerializer.h"
#include "TnbComparator.h"
 
 
 
namespace TNB
{
 
 
 
template<typename TYP>
class CNullableT : public IComparableT< TNB::CNullableT<TYP> >, public ISerializable
{
    bool    m_boIsNull;
    TYP     m_typ;
 
public:
 
    CNullableT(void) : m_typ(TYP()) , m_boIsNull(true) 
    {
    }
 
    CNullableT(const CNullableT<TYP>& t) : m_typ(t.m_typ) , m_boIsNull(t.m_boIsNull) 
    {
    }
 
    CNullableT(const TYP& t) : m_typ(t) , m_boIsNull(false) 
    {
    }
 
    CNullableT& operator=(const CNullableT& other)
    {
        m_typ = other.m_typ;
        m_boIsNull = other.m_boIsNull;
        return *this;
    }
 
    CNullableT& operator=(const TYP& t)
    {
        m_typ = t;
        m_boIsNull = false;
        return *this;
    }
 
    virtual INT_PTR Compare(const CNullableT<TYP>& t) const
    {
        if ( m_boIsNull )
        {
            return t.m_boIsNull ? 0 : -1;
        }
        if ( t.m_boIsNull ){ return 1; } 
        return IComparatorT<TYP>::GetDefault().CompareTo(m_typ, t.m_typ);
    }
 
    TYP& At(void)
    {
        if ( m_boIsNull ){ throw CNullPointerException(); }
        return m_typ;
    }
 
    const TYP& At(void) const
    {
        if ( m_boIsNull ){ throw CNullPointerException(); }
        return m_typ; 
    }
 
    operator TYP&(void) { return At(); }
 
    operator const TYP&(void) const { return At(); }
 
    TYP operator+(void) const
    {
        return At(); 
    }
    
    TYP operator-(void) const
    {
        return -At(); 
    }
 
    bool IsNull(void) const { return m_boIsNull; }
 
    void Null(void)
    {
        m_typ = TYP();
        m_boIsNull = true; 
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        _sr << m_boIsNull << m_typ;
    }
 
    virtual void Deserializer(const IDeserializer& ds)
    {
        ds >> m_boIsNull >> m_typ;
    }
};
 
 
 
}; // TNB