TnbValueParUnit.h

[詳解]

#pragma once
#include "TnbValueUnit.h"
 
 
 
//TNB Library
namespace TNB   
{
 
 
 
template<typename U1, typename U2, typename EX>
class CValueParUnitT : public U1, public U2, public EX, public CPfUnit
{
    DEFSUPER(CPfUnit);
protected:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    class CExCode
    {
        int     m_code;     
    public:
        typedef typename EX::EUnitCode EExCode;
        CExCode(void) : m_code(0) {}
        CExCode(EExCode code) : m_code(code) {}
        int ToInt(void) const { return m_code; };
    };
 
    class CNumeCode
    {
        int     m_code;     
    public:
        typedef typename U1::EUnitCode EU1Code;
        typedef typename EX::EUnitCode EExCode;
        typedef typename CValueUnitT<U1>::CCode CVuU1Code;
        CNumeCode(void) : m_code(0) {}
        CNumeCode(EU1Code code) : m_code(code) {}
        CNumeCode(EPfUnitCode code) : m_code(code) {}
        CNumeCode(CVuU1Code code) : m_code(code.ToInt()) {}
        explicit CNumeCode(CExCode code) : m_code(code.ToInt()) {}
        operator EU1Code(void) const { return EU1Code(HasPfCode() ? 0 : m_code); }
        operator EPfUnitCode(void) const { return EPfUnitCode(HasPfCode() ? m_code : 0); }
        operator EExCode(void) const { return EExCode(HasExCode() ? m_code : 0); }
        bool operator==(const CNumeCode& c) const { return m_code == c.m_code; }
        bool operator!=(const CNumeCode& c) const { return m_code != c.m_code; }
        bool HasPfCode(void) const { return (m_code & PFCODE) != 0; }
        bool HasExCode(void) const { return (m_code & U1::EXCODE) != 0; }
        int ToInt(void) const { return m_code; };
        EU1Code GetU1Code(void) const { return EU1Code(m_code); };
        EExCode GetExCode(void) const { return EExCode(m_code); };
        CVuU1Code GetCode(void) const 
        {
            CVuU1Code c;
            c.SetInt(m_code);
            return c;
        };
    };
    
    class CDenoCode
    {
        int     m_code;     
    public:
        typedef typename U2::EUnitCode EU2Code;
        typedef typename CValueUnitT<U2>::CCode CVuU2Code;
        CDenoCode(void) : m_code(0) {}
        CDenoCode(EU2Code code) : m_code(code) {}
        CDenoCode(EPfUnitCode code) : m_code(code) {}
        CDenoCode(CVuU2Code code) : m_code(code.ToInt()) {}
        operator EU2Code(void) const { return EU2Code(HasPfCode() ? 0 : m_code); }
        operator EPfUnitCode(void) const { return EPfUnitCode(HasPfCode() ? m_code : 0); }
        bool operator==(const CDenoCode& c) const { return m_code == c.m_code; }
        bool operator!=(const CDenoCode& c) const { return m_code != c.m_code; }
        bool HasPfCode(void) const { return (m_code & U2::PFCODE) != 0; }
        int ToInt(void) const { return m_code; };
        EU2Code GetU2Code(void) const { return EU2Code(m_code); };
        CVuU2Code GetCode(void) const 
        {
            CVuU2Code c;
            c.SetInt(m_code);
            return c;
        };
    };
 
    #endif //_TnbDOXYGEN
 
private:
    
    CRealNumber     m_value;            
    CNumeCode       m_numeCode;         
    CDenoCode       m_denoCode;         
 
    void m_ToUnit(CNumeCode code)
    {
        if ( m_numeCode != code )
        {
            ToNormalUnit();
            if ( code.HasExCode() )
            {
                if ( m_numeCode.ToInt() != 0 )
                {
                    CValueUnitT<U1> u1;
                    u1.Set(m_value, m_numeCode.GetU1Code());
                    m_value = u1.GetValue(U1::EUnitCode(0));
                }
                if ( m_denoCode.ToInt() != 0 )
                {
                    CValueUnitT<U2> u2;
                    u2.Set(1, U2::EUnitCode(0));
                    m_value *= u2.GetValue(m_denoCode.GetU2Code());
                    m_denoCode = U2::EUnitCode(0);
                }
                const TUnitParam* P = EX::GetParam(code.GetExCode());
                m_value *= P->doCoefficient;
                m_value += P->doRevise;
            }
            else
            {
                CValueUnitT<U1> u;
                u.Set(m_value, m_numeCode.GetU1Code());
                u.ToUnit(code.GetU1Code());
                m_value = u.GetValue();
            }
            m_numeCode = code;
        }
    }
 
public:
 
    enum { KINDCODE = EX::KINDCODE };
 
    CValueParUnitT(void) : _super(), m_value(), m_numeCode(), m_denoCode()
    {
    }
 
    CValueParUnitT(const CRealNumber& v) 
            : _super(), m_value(v), m_numeCode(), m_denoCode()
    {
    }
 
    CValueParUnitT(const CRealNumber& v, CExCode code) 
            : _super(), m_value(v), m_numeCode(code), m_denoCode()
    {
    }
 
    CValueParUnitT(const CRealNumber& v, CNumeCode c1, CDenoCode c2) 
            : _super(), m_value(v), m_numeCode(c1), m_denoCode(c2)
    {
    }
 
    void Set(const CRealNumber& v)
    {
        m_value     = v;
    }
 
    void Set(const CRealNumber& v, CExCode code)
    {
        m_value     = v;
        m_numeCode  = CNumeCode(code);
        m_denoCode  = CDenoCode();
    }
 
    void Set(const CRealNumber& v, CNumeCode c1, CDenoCode c2)
    {
        m_value     = v;
        m_numeCode  = c1;
        m_denoCode  = c2;
    }
 
    CStr ToString(LPCTSTR lpszFormat = NULL) const
    {
        return m_value.ToString(lpszFormat) + GetUnitMarkString();
    }
 
    CStr ToString(CExCode code, LPCTSTR lpszFormat = NULL) const
    {
        CValueParUnitT u = *this;
        u.ToUnit(code);
        return u.ToString(lpszFormat);
    }
 
    CStr ToString(CNumeCode c1, CDenoCode c2, LPCTSTR lpszFormat = NULL) const
    {
        CValueParUnitT u = *this;
        u.ToUnit(c1, c2);
        return u.ToString(lpszFormat);
    }
 
    bool HasExCode(void) const
    {
        return m_numeCode.HasExCode();
    }
 
    CNumeCode GetUnitCode(void) const
    {
        return m_numeCode;
    }
 
    CDenoCode GetDenoUnitCode(void) const
    {
        return m_denoCode;
    }
 
    CStr GetUnitMarkString(void) const
    {
        CStr s;
        if ( m_numeCode.HasExCode() )
        {
            s = CValueUnitT<EX>::GetUnitMarkString(m_numeCode.GetExCode());
        }
        else
        {
            s = CValueUnitT<U1>::GetUnitMarkString(m_numeCode.GetU1Code());
            s += _T("/") + CValueUnitT<U2>::GetUnitMarkString(m_denoCode.GetU2Code());
        }
        return s;
    }
 
    CStr GetUnitJapanString(void) const
    {
        CStr s;
        if ( m_numeCode.HasExCode() )
        {
            s = CValueUnitT<EX>::GetUnitJapanString(m_numeCode.GetExCode());
        }
        else
        {
            s = CValueUnitT<U1>::GetUnitJapanString(m_numeCode.GetU1Code());
            s += _T(" 毎 ") + CValueUnitT<U2>::GetUnitJapanString(m_denoCode.GetU2Code());
        }
        return s;
    }
 
    void ToNormalUnit(void)
    {
        if ( m_numeCode.HasExCode() )
        {
            //今、EXコードなら基本単位に変換
            const TUnitParam* P = EX::GetParam(m_numeCode.GetExCode());
            m_value -= P->doRevise;
            m_value /= P->doCoefficient;
            m_numeCode = U1::EUnitCode(0);
            m_denoCode = U2::EUnitCode(0);
        }
    }
 
    CValueParUnitT& ToUnit(CExCode code)
    {
        m_ToUnit(CNumeCode(code));
        return *this;
    }
 
    CValueParUnitT& ToUnit(CNumeCode c1, CDenoCode c2)
    {
        m_ToUnit(c1);
        return ToDenoUnit(c2);
    }
 
    CValueParUnitT& ToDenoUnit(CDenoCode code)
    {
        if ( m_numeCode.HasExCode() )
        {
            const TUnitParam* P = EX::GetParam(m_numeCode.GetExCode());
            m_value -= P->doRevise;
            m_value /= P->doCoefficient;
            m_numeCode = U1::EUnitCode(0);
            m_denoCode = U2::EUnitCode(0);
        }
        if ( m_denoCode != code )
        {
            CValueUnitT<U2> u;
            u.Set(1, code.GetU2Code());
            u.ToUnit(m_denoCode.GetU2Code());
            m_value *= u.GetValue();
            m_denoCode = code;
        }
        return *this;
    }
 
    CRealNumber GetValue(void) const
    {
        return m_value;
    }
 
    CRealNumber GetValue(CExCode code) const
    {
        CValueParUnitT r = *this;
        r.ToUnit(code);
        return r.GetValue();
    }
 
    CRealNumber GetValue(CNumeCode c1, CDenoCode c2) const
    {
        CValueParUnitT r = *this;
        r.ToUnit(c1, c2);
        return r.GetValue();
    }
 
    CValueParUnitT& operator+=(const CValueParUnitT& u)
    {
        m_value += u.GetValue(m_numeCode, m_denoCode);
        return *this;
    }
 
    CValueParUnitT operator+(const CValueParUnitT& u) const
    {
        CValueParUnitT r = *this;
        return r += u;
    }
 
    CValueParUnitT& operator+=(const CRealNumber& v)
    {
        m_value += v;
        return *this;
    }
 
    CValueParUnitT operator+(const CRealNumber& v) const
    {
        CValueParUnitT r = *this;
        return r += v;
    }
 
    friend CValueParUnitT operator+(const CRealNumber& v, const CValueParUnitT& u)
    {
        return u + v;
    }
 
    CValueParUnitT& operator-=(const CValueParUnitT& u)
    {
        m_value -= u.GetValue(m_numeCode, m_denoCode);
        return *this;
    }
 
    CValueParUnitT operator-(const CValueParUnitT& u) const
    {
        CValueParUnitT r = *this;
        return r -= u;
    }
 
    CValueParUnitT& operator-=(const CRealNumber& v)
    {
        m_value -= v;
        return *this;
    }
 
    CValueParUnitT operator-(const CRealNumber& v) const
    {
        CValueParUnitT r = *this;
        return r -= v;
    }
 
    friend CValueParUnitT operator-(const CRealNumber& v, const CValueParUnitT& u)
    {
        CValueParUnitT r = u;
        u.m_value = v - u.m_value;
        return *this;
    }
 
    CValueParUnitT& operator*=(const CRealNumber& v)
    {
        m_value *= v;
        return *this;
    }
 
    CValueParUnitT operator*(const CRealNumber& v) const
    {
        CValueParUnitT r = *this;
        return r *= v;
    }
 
    friend CValueParUnitT operator*(const CRealNumber& v, const CValueParUnitT& u)
    {
        return u * v;
    }
 
    CValueUnitT<U1> operator*(const CValueUnitT<U2>& t) const
    {
        CValueParUnitT v = *this;
        v.ToNormalUnit();
        v.ToDenoUnit(t.GetUnitCode());
        CValueUnitT<U1> r;
        r.Set(v.GetValue() * t.GetValue(), v.GetUnitCode().GetCode());
        return r;
    }
 
    friend CValueUnitT<U1> operator*(const CValueUnitT<U2>& t, const CValueParUnitT& s)
    {
        return s * t;
    }
 
    CValueParUnitT& operator/=(const CRealNumber& v)
    {
        m_value /= v;
        return *this;
    }
 
    CValueParUnitT operator/(const CRealNumber& v) const
    {
        CValueParUnitT r = *this;
        return r /= v;
    }
    
    friend CValueUnitT<U2> operator/(const CValueUnitT<U1>& d, const CValueParUnitT& s)
    {
        CValueUnitT<U2>::CCode tu = s.GetDenoUnitCode().GetCode();
        CValueUnitT<U2> r;
        r.Set(d.GetValue() / s.GetValue(d.GetUnitCode(), tu), tu);
        return r;
    }
 
    CRealNumber operator/(const CValueParUnitT& u) const
    {
        return m_value / u.GetValue(m_numeCode, m_denoCode);
    }
 
    bool operator==(const CValueParUnitT& t) const { return m_value == t.GetValue(m_numeCode, m_denoCode); }
    
    bool operator!=(const CValueParUnitT& t) const { return m_value != t.GetValue(m_numeCode, m_denoCode); }
    
    bool operator<(const CValueParUnitT& t) const { return m_value < t.GetValue(m_numeCode, m_denoCode); }
    
    bool operator<=(const CValueParUnitT& t) const { return m_value <= t.GetValue(m_numeCode, m_denoCode); }
    
    bool operator>(const CValueParUnitT& t) const { return m_value > t.GetValue(m_numeCode, m_denoCode); }
    
    bool operator>=(const CValueParUnitT& t) const { return m_value >= t.GetValue(m_numeCode, m_denoCode); }
 
 
    //-----------------------
 
 
    static CStr GetUnitKindString(void)
    {
        return EX::GetKindString();
    }
 
    static DWORD GetUnitKindCode(void)
    {
        return EX::KINDCODE;
    }
};
 
 
 
class CUnitSpeed : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("速度"); }
 
    enum { KINDCODE = 'SP' };
 
    enum EUnitCode
    {
        KPH = EXCODE,       
        FPM,                
        KT,                 
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                 係数
            {   _T("kph"),      _T("時速"),               3600.0 * 1.0E-3     },  // km/h
            {   _T("fpm"),      _T("fpm"),              60.0 * 3.28084      },  // ft/min
            {   _T("kt"),       _T("ノット"),          3600.0 / 1852.0     },  // kt
        };
        int c = code - EXCODE;
        if ( c >= 0 && c < countof(A) )
        {
            return &A[c];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueParUnitT<CUnitDistance, CUnitTime, CUnitSpeed> CValueSpeed;
 
inline CValueSpeed operator/(const CValueDistance& d, const CValueTime& t)
{
    return CValueSpeed(d.GetValue() / t.GetValue(), d.GetUnitCode(), t.GetUnitCode());
}
 
inline CValueDistance operator/(const CValueSpeed& s, const CValueFrequency& f)
{
    CRealNumber one(1.0);
    return s * (one / f);
}
 
 
 
class CUnitAcceleration : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("加速度"); }
 
    enum { KINDCODE = 'AC' };
 
    enum EUnitCode
    {
        GAL = EXCODE,       
        G                   
    };
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        const static TUnitParam A[] = 
        {
            //  単位文字列       日本語                 係数
            {   _T("Gal"),      _T("ガル"),               100             },  // Gal
            {   _T("G"),        _T("重力加速度"),        1.0 / 9.80665   },  // G
        };
        int c = code - EXCODE;
        if ( c >= 0 && c < countof(A) )
        {
            return &A[c];
        }
        throw CNoSuchTypeException();
    }
};
 
typedef CValueParUnitT<CUnitDistance, CUnitTime2, CUnitAcceleration> CValueAcceleration;
 
inline CValueAcceleration operator*(const CValueSpeed& s, const CValueFrequency& f)
{
    return CValueAcceleration(s.GetValue(s.M, s.SEC) * f.GetValue(f.HZ), CValueSpeed::M, CValueTime2::SEC2);
}
 
inline CValueAcceleration operator*(const CValueFrequency& f, const CValueSpeed& s)
{
    return s * f;
}
 
inline CValueAcceleration operator/(const CValueDistance& d, const CValueTime2& t)
{
    return CValueAcceleration(d.GetValue() / t.GetValue(), d.GetUnitCode(), t.GetUnitCode());
}
 
inline CValueAcceleration operator/(const CValueSpeed& s, const CValueTime& t)
{
    return CValueAcceleration(s.GetValue(s.M, s.SEC) / t.GetValue(t.SEC), CValueSpeed::M, CValueTime2::SEC2);
}
 
inline CValueSpeed operator*(const CValueAcceleration& a, const CValueTime& t)
{
    return CValueSpeed(a.GetValue(a.M, a.SEC2) * t.GetValue(t.SEC), a.M, t.SEC);
}
 
inline CValueSpeed operator*(const CValueTime& t, const CValueAcceleration& a)
{
    return a * t;
}
 
inline CValueSpeed operator/(const CValueAcceleration& a, const CValueFrequency& f)
{
    return CValueSpeed(a.GetValue(a.M, a.SEC2) / f.GetValue(f.HZ), a.M, CValueSpeed::SEC);
}
 
 
 
class CUnitDensity2 : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("面積"); }
 
    enum { KINDCODE = '2D' };
 
    enum EUnitCode {};
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        throw CNoSuchTypeException();
    }
};
 
typedef CValueParUnitT<CUnitWeight, CUnitArea, CUnitDensity2> CValueDensity2;
 
inline CValueDensity2 operator /(const CValueWeight& d, const CValueArea& a)
{
    return CValueDensity2(d.GetValue() / a.GetValue(), d.GetUnitCode(), a.GetUnitCode());
}
 
 
 
class CUnitDensity3 : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("体積密度"); }
 
    enum { KINDCODE = 'DE' };
 
    enum EUnitCode {};
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        throw CNoSuchTypeException();
    }
};
 
typedef CValueParUnitT<CUnitWeight, CUnitCubic, CUnitDensity3> CValueDensity3;
 
inline CValueDensity3 operator /(const CValueWeight& d, const CValueCubic& t)
{
    return CValueDensity3(d.GetValue() / t.GetValue(), d.GetUnitCode(), t.GetUnitCode());
}
 
 
 
class CUnitFlux : public CAbstractUnit
{
public:
 
    static LPCTSTR GetKindString(void) { return _T("流量"); }
 
    enum { KINDCODE = 'FL' };
 
    enum EUnitCode {};
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        throw CNoSuchTypeException();
    }
};
 
typedef CValueParUnitT<CUnitCubic, CUnitTime, CUnitFlux> CValueFlux;
 
inline CValueFlux operator /(const CValueCubic& c, const CValueTime& t)
{
    return CValueFlux(c.GetValue() / t.GetValue(), c.GetUnitCode(), t.GetUnitCode());
}
 
 
 
//-------------------
 
 
 
class CUnitParDummy : public CAbstractUnit
{
public:
 
    enum { KINDCODE = 0 };
 
    enum EUnitCode  {};
 
    static const TUnitParam* GetParam(EUnitCode code)
    {
        throw CNoSuchTypeException();
    }
};
 
template <typename U1, typename U2>
class CValueParT : public CValueParUnitT<U1, U2, CUnitParDummy>
{
    typedef CValueParUnitT<U1, U2, CUnitParDummy> _super;   
    DEFSUPER(_super);
public:
 
    enum { KINDCODE = U1::KINDCODE * 0x1000 + U2::KINDCODE };
 
    static CStr GetKindString(void)
    {
        CStr s;
        s.Format(_T("%s 毎 %s"), U1::GetKindString(), U2::GetKindString());
        return s; 
    }
 
    CValueParT(void) : _super()
    {
    }
 
    CValueParT(const CRealNumber& v, CNumeCode c1, CDenoCode c2) 
            : _super(v, c1, c2)
    {
    }
 
    friend CValueParT operator /(const CValueUnitT<U1>& u1, const CValueUnitT<U2>& u2)
    {
        return CValueParT(u1.GetValue() / u2.GetValue(), u1.GetUnitCode(), u2.GetUnitCode());
    }
};
 
 
 
}; // TNB