ZFTime.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFTime_h_
#define _ZFI_ZFTime_h_
 
#include "ZFObject.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
// ZFTimeValue
zfclassPOD ZFLIB_ZFCore ZFTimeValue {
public:
    zftimet sec;     
    zftimet usec;    
};
ZFCORE_POD_DECLARE_NO_COMPARER(ZFTimeValue)
 

ZFTYPEID_DECLARE(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValue)
ZFTYPEID_REG(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValue)
ZFOUTPUT_TYPE(ZFTimeValue, {ZFTimeValueToStringT(s, v);})

ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueZero)
ZFMETHOD_FUNC_INLINE_DECLARE_2(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueCreate
        , ZFMP_IN(zftimet, sec)
        , ZFMP_IN(zftimet, usec)
        ) {
    ZFTimeValue ret = {sec, usec};
    return ret;
}

ZFMETHOD_FUNC_INLINE_DECLARE_1(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueFromMiliSeconds
        , ZFMP_IN(zftimet, t)
        ) {
    ZFTimeValue ret = {(zftimet)(t / 1000), (zftimet)((t % 1000) * 1000)};
    return ret;
}

ZFMETHOD_FUNC_INLINE_DECLARE_1(ZFLIB_ZFCore, zftimet, ZFTimeValueToMiliSeconds
        , ZFMP_IN(const ZFTimeValue &, v)
        ) {
    return (zftimet)(v.sec * 1000 + v.usec / 1000);
}

ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, void, ZFTimeValueNormalize
        , ZFMP_IN_OUT(ZFTimeValue &, v)
        )
 

ZFMETHOD_FUNC_INLINE_DECLARE_3(ZFLIB_ZFCore, void, ZFTimeValueDec
        , ZFMP_OUT(ZFTimeValue &, result)
        , ZFMP_IN(const ZFTimeValue &, tv1)
        , ZFMP_IN(const ZFTimeValue &, tv2)
        ) {
    result.sec = tv1.sec - tv2.sec;
    result.usec = tv1.usec - tv2.usec;
    ZFTimeValueNormalize(result);
}

ZFMETHOD_FUNC_INLINE_DECLARE_2(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueDec
        , ZFMP_IN(const ZFTimeValue &, tv1)
        , ZFMP_IN(const ZFTimeValue &, tv2)
        ) {
    ZFTimeValue result;
    ZFTimeValueDec(result, tv1, tv2);
    return result;
}

ZFMETHOD_FUNC_INLINE_DECLARE_3(ZFLIB_ZFCore, void, ZFTimeValueInc
        , ZFMP_OUT(ZFTimeValue &, result)
        , ZFMP_IN(const ZFTimeValue &, tv1)
        , ZFMP_IN(const ZFTimeValue &, tv2)
        ) {
    result.sec = tv1.sec + tv2.sec;
    result.usec = tv1.usec + tv2.usec;
    ZFTimeValueNormalize(result);
}

ZFMETHOD_FUNC_INLINE_DECLARE_2(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueInc
        , ZFMP_IN(const ZFTimeValue &, tv1)
        , ZFMP_IN(const ZFTimeValue &, tv2)
        ) {
    ZFTimeValue result;
    ZFTimeValueInc(result, tv1, tv2);
    return result;
}

ZFMETHOD_FUNC_INLINE_DECLARE_3(ZFLIB_ZFCore, void, ZFTimeValueMul
        , ZFMP_OUT(ZFTimeValue &, result)
        , ZFMP_IN(const ZFTimeValue &, tv)
        , ZFMP_IN(zfindex, v)
        ) {
    result.sec = tv.sec * v;
    result.usec = tv.usec * v;
    ZFTimeValueNormalize(result);
}

ZFMETHOD_FUNC_INLINE_DECLARE_2(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueMul
        , ZFMP_IN(const ZFTimeValue &, tv)
        , ZFMP_IN(zfindex, v)
        ) {
    ZFTimeValue result;
    ZFTimeValueMul(result, tv, v);
    return result;
}

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, void, ZFTimeValueDiv
        , ZFMP_OUT(ZFTimeValue &, result)
        , ZFMP_IN(const ZFTimeValue &, tv)
        , ZFMP_IN(zfindex, v)
        )
ZFMETHOD_FUNC_INLINE_DECLARE_2(ZFLIB_ZFCore, ZFTimeValue, ZFTimeValueDiv
        , ZFMP_IN(const ZFTimeValue &, tv)
        , ZFMP_IN(zfindex, v)
        ) {
    ZFTimeValue result;
    ZFTimeValueDiv(result, tv, v);
    return result;
}

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, ZFCompareResult, ZFTimeValueCompare
        , ZFMP_IN(const ZFTimeValue &, tv1)
        , ZFMP_IN(const ZFTimeValue &, tv2)
        )
 

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFTimeValueToStringFriendlyT
        , ZFMP_IN_OUT(zfstring &, s)
        , ZFMP_IN(ZFTimeValue const &, v)
        )
ZFMETHOD_FUNC_INLINE_DECLARE_1(ZFLIB_ZFCore, zfstring, ZFTimeValueToStringFriendly
        , ZFMP_IN(ZFTimeValue const &, v)
        ) {
    zfstring s;
    ZFTimeValueToStringFriendlyT(s, v);
    return s;
}

inline zfbool operator == (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) == ZFCompareEqual);}
inline zfbool operator != (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) != ZFCompareEqual);}
inline zfbool operator < (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) == ZFCompareSmaller);}
inline zfbool operator <= (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) != ZFCompareGreater);}
inline zfbool operator > (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) == ZFCompareGreater);}
inline zfbool operator >= (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return (ZFTimeValueCompare(v0, v1) != ZFCompareSmaller);}
inline ZFTimeValue operator + (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return ZFTimeValueInc(v0, v1);}
inline ZFTimeValue operator - (ZF_IN const ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {return ZFTimeValueDec(v0, v1);}
inline void operator += (ZF_IN_OUT ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {ZFTimeValueInc(v0, v0, v1);}
inline void operator -= (ZF_IN_OUT ZFTimeValue &v0, ZF_IN const ZFTimeValue &v1) {ZFTimeValueDec(v0, v0, v1);}
inline ZFTimeValue operator * (ZF_IN const ZFTimeValue &v0, ZF_IN zfindex v1) {return ZFTimeValueMul(v0, v1);}
inline ZFTimeValue operator / (ZF_IN const ZFTimeValue &v0, ZF_IN zfindex v1) {return ZFTimeValueDiv(v0, v1);}
inline void operator *= (ZF_IN_OUT ZFTimeValue &v0, ZF_IN zfindex v1) {ZFTimeValueMul(v0, v0, v1);}
inline void operator /= (ZF_IN_OUT ZFTimeValue &v0, ZF_IN zfindex v1) {ZFTimeValueDiv(v0, v0, v1);}
 
// ============================================================
// ZFTimeInfo
zfclassPOD ZFLIB_ZFCore ZFTimeInfo {
public:
    zfint year;          
    zfuint month;        
    zfuint day;          
    zfuint hour;         
    zfuint minute;       
    zfuint second;       
    zfuint miliSecond;   
    zfuint microSecond;  
};
ZFCORE_POD_DECLARE(ZFTimeInfo)
 
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFCore, ZFTimeInfo, ZFTimeInfo)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFCore, ZFTimeInfo, ZFTimeInfo)
ZFOUTPUT_TYPE_DECLARE(ZFLIB_ZFCore, ZFTimeInfo)

ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, ZFTimeInfo, ZFTimeInfoZero)
ZFMETHOD_FUNC_INLINE_DECLARE_8(ZFLIB_ZFCore, ZFTimeInfo, ZFTimeInfoCreate
        , ZFMP_IN(zfint const &, year)
        , ZFMP_IN(zfuint const &, month)
        , ZFMP_IN(zfuint const &, day)
        , ZFMP_IN(zfuint const &, hour)
        , ZFMP_IN(zfuint const &, minute)
        , ZFMP_IN(zfuint const &, second)
        , ZFMP_IN(zfuint const &, miliSecond)
        , ZFMP_IN(zfuint const &, microSecond)
        ) {
    ZFTimeInfo ret = {year, month, day, hour, minute, second, miliSecond, microSecond};
    return ret;
}

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFTimeInfoToStringT
        , ZFMP_IN_OUT(zfstring &, s)
        , ZFMP_IN(ZFTimeInfo const &, v)
        )
ZFMETHOD_FUNC_INLINE_DECLARE_1(ZFLIB_ZFCore, zfstring, ZFTimeInfoToString
        , ZFMP_IN(ZFTimeInfo const &, v)
        ) {
    zfstring s;
    ZFTimeInfoToStringT(s, v);
    return s;
}
 
// ============================================================
// ZFTime
#define ZFSerializableKeyword_ZFTime_timeValue "timeValue"
#define ZFSerializableKeyword_ZFTime_timeZone "timeZone"
 
zfclassFwd _ZFP_ZFTimePrivate;
zfclass ZFLIB_ZFCore ZFTime : zfextend ZFStyle {
    ZFOBJECT_DECLARE(ZFTime, ZFStyle)
 
protected:
    zfoverride
    virtual zfbool serializableOnSerializeFromData(
            ZF_IN const ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            , ZF_OUT_OPT ZFSerializableData *errorPos = zfnull
            );
    zfoverride
    virtual zfbool serializableOnSerializeToData(
            ZF_IN_OUT ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *errorHint = zfnull
            , ZF_IN_OPT ZFSerializable *refOwner = zfnull
            );
 
protected:
    zfoverride
    virtual void styleableOnCopyFrom(ZF_IN ZFObject *anotherStyleable) {
        zfsuperI(ZFStyleable)::styleableOnCopyFrom(anotherStyleable);
        this->timeValue(zfcast(zfself *, anotherStyleable)->timeValue());
        this->timeZone(zfcast(zfself *, anotherStyleable)->timeZone());
    }
 
public:
    ZFMETHOD_DECLARE_STATIC_1(zfbool, leapYear
            , ZFMP_IN(zfint, year)
            )
    ZFMETHOD_DECLARE_STATIC_2(zfint, leapYearBetween
            , ZFMP_IN(zfint, year1)
            , ZFMP_IN(zfint, year2)
            )

    ZFMETHOD_DECLARE_STATIC_0(zftimet, timestamp)

    ZFMETHOD_DECLARE_STATIC_0(ZFTimeValue, currentTimeValue)
    ZFMETHOD_DECLARE_STATIC_0(zftimet, currentTime)
    ZFMETHOD_DECLARE_STATIC_1(ZFTimeInfo, currentTimeInfo
            , ZFMP_IN_OPT(const ZFTimeValue &, localTimeZone, ZFTime::timeZoneLocal())
            )
    ZFMETHOD_DECLARE_STATIC_2(zfbool, timeInfoFromTimeValue
            , ZFMP_OUT(ZFTimeInfo &, ti)
            , ZFMP_IN(const ZFTimeValue &, tv)
            )
    ZFMETHOD_DECLARE_STATIC_2(zfbool, timeInfoToTimeValue
            , ZFMP_OUT(ZFTimeValue &, tv)
            , ZFMP_IN(const ZFTimeInfo &, ti)
            )
    static zfbool timeInfoToTimeValue(
            ZF_OUT ZFTimeValue &tv
            , ZF_IN zfint year
            , ZF_IN zfuint month
            , ZF_IN zfuint day
            , ZF_IN zfuint hour
            , ZF_IN zfuint minute
            , ZF_IN zfuint second
            , ZF_IN zfuint miliSecond
            , ZF_IN zfuint microSecond
            );

    ZFMETHOD_DECLARE_STATIC_0(const ZFTimeValue &, timeZoneLocal)
 
protected:
    ZFOBJECT_ON_INIT_DECLARE_1(ZFMP_IN(ZFTime *, time))
    ZFOBJECT_ON_INIT_DECLARE_2(
            ZFMP_IN(const ZFTimeValue &, tv)
            , ZFMP_IN_OPT(const ZFTimeValue &, timeZone, ZFTime::timeZoneLocal)()
            )
    ZFOBJECT_ON_INIT_DECLARE_2(
            ZFMP_IN(const ZFTimeInfo &, ti)
            , ZFMP_IN_OPT(const ZFTimeValue &, timeZone, ZFTime::timeZoneLocal)()
            )
 
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnDealloc(void);
 
protected:
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret);
 
public:
    zfoverride
    virtual zfidentity objectHashImpl(void);

    zfoverride
    virtual ZFCompareResult objectCompareImpl(ZF_IN ZFObject *anotherObj);
 
public:
    ZFMETHOD_DECLARE_1(zfbool, timeValue
            , ZFMP_IN(const ZFTimeValue &, tv)
            )
    ZFMETHOD_DECLARE_0(const ZFTimeValue &, timeValue)

    ZFMETHOD_DECLARE_1(zfbool, timeZone
            , ZFMP_IN(const ZFTimeValue &, timeZone)
            )
    ZFMETHOD_DECLARE_0(const ZFTimeValue &, timeZone)

    ZFMETHOD_DECLARE_0(const ZFTimeValue &, timeValueAppliedTimeZone)

    virtual zfbool timeInfo(
            ZF_IN zfint year
            , ZF_IN zfuint month
            , ZF_IN zfuint day
            , ZF_IN zfuint hour
            , ZF_IN zfuint minute
            , ZF_IN zfuint second
            , ZF_IN zfuint miliSecond
            , ZF_IN zfuint microSecond
            , ZF_IN_OPT const ZFTimeValue &tz = ZFTime::timeZoneLocal()
            );
    ZFMETHOD_DECLARE_2(zfbool, timeInfo
            , ZFMP_IN(const ZFTimeInfo &, ti)
            , ZFMP_IN_OPT(const ZFTimeValue &, tz, ZFTime::timeZoneLocal())
            )
    ZFMETHOD_DECLARE_0(const ZFTimeInfo &, timeInfo)

    ZFMETHOD_DECLARE_0(zfint, year)

    ZFMETHOD_DECLARE_0(zfuint, month)

    ZFMETHOD_DECLARE_0(zfuint, day)

    ZFMETHOD_DECLARE_0(zfuint, dayOfWeek)
    ZFMETHOD_DECLARE_0(zfuint, dayOfYear)

    ZFMETHOD_DECLARE_0(zfuint, hour)

    ZFMETHOD_DECLARE_0(zfuint, minute)

    ZFMETHOD_DECLARE_0(zfuint, second)

    ZFMETHOD_DECLARE_0(zfuint, miliSecond)

    ZFMETHOD_DECLARE_0(zfuint, microSecond)
 
private:
    _ZFP_ZFTimePrivate *d;
};
 
// ============================================================
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneMinute)
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneHour)
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneDay)
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneWeek)
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneMonth)
ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_ZFCore, zftimet, zftimetOneYear)

#define zftimetOneMinute() 60000LL // 60 * 1000
#define zftimetOneHour() 3600000LL // 60 * 60 * 1000
#define zftimetOneDay() 86400000LL // 60 * 60 * 24 * 1000
#define zftimetOneWeek() 604800000LL // 60 * 60 * 24 * 7 * 1000
#define zftimetOneMonth() 2592000000LL // 60 * 60 * 24 * 30 * 1000
#define zftimetOneYear() 31536000000LL // 60 * 60 * 24 * 365 * 1000
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFTime_h_