ZFCoreUtilTemplate.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFCoreUtilTemplate_h_
#define _ZFI_ZFCoreUtilTemplate_h_
 
#include "ZFIdentityUtil.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
// zftValue
template<typename T_Type>
zfclassLikePOD zftValue {
public:
    T_Type zfv;
public:
    zftValue(void) : zfv() {}
    zftValue(ZF_IN T_Type const &ref) : zfv(ref) {}
    zftValue(ZF_IN zftValue<T_Type> const &ref) : zfv(ref.zfv) {}
    template<typename T_Ref> zftValue(ZF_IN T_Ref const &ref) : zfv(ref) {}
    inline zftValue<T_Type> &operator = (ZF_IN T_Type const &ref) {zfv = ref; return *this;}
    inline zftValue<T_Type> &operator = (ZF_IN zftValue<T_Type> const &ref) {zfv = ref.zfv; return *this;}
    template<typename T_Ref> inline zftValue<T_Type> &operator = (ZF_IN T_Ref const &ref) {zfv = ref; return *this;}
    inline operator T_Type const & (void) const {return zfv;}
    inline operator T_Type & (void) {return zfv;}
};
 
// ============================================================
#define zftType(...) \
    _ZFP_zftType<void(__VA_ARGS__)>::Type
template<typename T>
zfclassNotPOD _ZFP_zftType;
template<typename T_Ret, typename T_Type>
zfclassNotPOD _ZFP_zftType<T_Ret (T_Type)> {
public:
    typedef T_Type Type;
};
 
// ============================================================
// zftTraits
typedef enum {
    zftTraitsModifier_N, 
    zftTraitsModifier_R, 
    zftTraitsModifier_CR, 
    zftTraitsModifier_P, 
    zftTraitsModifier_PR, 
    zftTraitsModifier_PCR, 
    zftTraitsModifier_CP, 
    zftTraitsModifier_CPR, 
    zftTraitsModifier_CPCR, 
} zftTraitsModifier;

#define zftTraitsModifierName_N "N"
#define zftTraitsModifierName_R "R"
#define zftTraitsModifierName_CR "CR"
#define zftTraitsModifierName_P "P"
#define zftTraitsModifierName_PR "PR"
#define zftTraitsModifierName_PCR "PCR"
#define zftTraitsModifierName_CP "CP"
#define zftTraitsModifierName_CPR "CPR"
#define zftTraitsModifierName_CPCR "CPCR"
template<typename T_Type>
zfclassNotPOD zftTraits {
public:
    enum {
        TrIsPtr = 0, 
        TrIsRef = 0, 
        TrModifier = (int)zftTraitsModifier_N, 
    };
    typedef T_Type                  TrType;         
    typedef T_Type &                TrRef;          
    typedef T_Type const &          TrConstRef;     
    typedef T_Type *                TrPtr;          
    typedef const T_Type *          TrConstPtr;     
    typedef T_Type                  TrNoRef;        
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_N;}
};

/*
 * here is a list
 *   Type
 *   Type &
 *   Type const &
 *   Type *
 *   Type *&
 *   Type * const &
 *   const Type *
 *   const Type *&
 *   const Type * const &
 *
 *   void
 *   void *
 *   const void *
 *   void *&
 *   void * const &
 *   const void *&
 *   const void * const &
 */
template<typename T_Type>
zfclassNotPOD zftTraits<T_Type &> {
public:
    enum {
        TrIsPtr = 0,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_R,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef T_Type                  TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_R;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<T_Type const &> {
public:
    enum {
        TrIsPtr = 0,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_CR,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef T_Type                  TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CR;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<T_Type *> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_P,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef T_Type *                TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_P;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<T_Type *&> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_PR,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef T_Type *                TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_PR;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<T_Type * const &> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_PCR,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef T_Type *                TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_PCR;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<const T_Type *> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_CP,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef const T_Type *          TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CP;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<const T_Type *&> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_CPR,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef const T_Type *          TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CPR;}
};
template<typename T_Type>
zfclassNotPOD zftTraits<const T_Type * const &> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_CPCR,
    };
    typedef T_Type                  TrType;
    typedef T_Type &                TrRef;
    typedef T_Type const &          TrConstRef;
    typedef T_Type *                TrPtr;
    typedef const T_Type *          TrConstPtr;
    typedef const T_Type *          TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CPCR;}
};
 
template<>
zfclassNotPOD zftTraits<void> {
public:
    enum {
        TrIsPtr = 0,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_N,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void                    TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef void                    TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_N;}
};
template<>
zfclassNotPOD zftTraits<const void> {
public:
    enum {
        TrIsPtr = 0,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_N,
    };
    typedef const void              TrType;
    typedef const void              TrRef;
    typedef const void              TrConstRef;
    typedef const void *            TrPtr;
    typedef const void *            TrConstPtr;
    typedef const void              TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_N;}
};
template<>
zfclassNotPOD zftTraits<void *> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_P,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void * const &          TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef void *                  TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_P;}
};
template<>
zfclassNotPOD zftTraits<const void *> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 0,
        TrModifier = (int)zftTraitsModifier_CP,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef const void * const &    TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef const void *            TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CP;}
};
template<>
zfclassNotPOD zftTraits<void *&> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_PR,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void * const &          TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef void *                  TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_PR;}
};
template<>
zfclassNotPOD zftTraits<void * const &> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_PCR,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void * const &          TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef void *                  TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_PCR;}
};
template<>
zfclassNotPOD zftTraits<const void *&> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_CPR,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void * const &          TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef const void *            TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CPR;}
};
template<>
zfclassNotPOD zftTraits<const void * const &> {
public:
    enum {
        TrIsPtr = 1,
        TrIsRef = 1,
        TrModifier = (int)zftTraitsModifier_CPCR,
    };
    typedef void                    TrType;
    typedef void                    TrRef;
    typedef void * const &          TrConstRef;
    typedef void *                  TrPtr;
    typedef const void *            TrConstPtr;
    typedef const void *            TrNoRef;
    static const zfchar *ModifierName(void) {return zftTraitsModifierName_CPCR;}
};
 
// ============================================================
template<int cond = 0, typename T_Fix = void>
zfclassNotPOD zftEnableIf {
};

template<>
zfclassNotPOD zftEnableIf<1> {
public:
    typedef void Value;
};
 
// ============================================================
template<typename T0, typename T1>
zfclassNotPOD zftIsSame {
public:
    enum {
        Value = 0
    };
};

template<typename T>
zfclassNotPOD zftIsSame<T, T> {
public:
    enum {
        Value = 1
    };
};
 
// ============================================================
template<typename T>
zfclassNotPOD zftIsClass {
private:
    template<typename U>
    static char _test(int U::*);
    template<typename U>
    static int _test(...);
public:
    enum {
        Value = ((sizeof(_test<T>(0)) == sizeof(char)) ? 1 : 0)
    };
};
 
// ============================================================
template<typename TChild, typename TBase,
    bool _IsClass = (zftIsClass<TChild>::Value && zftIsClass<TBase>::Value)>
zfclassNotPOD zftIsTypeOf {
private:
    template<typename T_Dummy>
    static char _test(TChild const &, T_Dummy);
    static int _test(TBase const &, int);
    zfclassNotPOD _Conv {
    public:
        operator TChild const & (void);
        operator TBase const & (void) const;
    };
public:
    enum {
        Value = ((sizeof(_test(_Conv(), 0)) == sizeof(char)) ? 1 : 0)
    };
};

template<typename TChild, typename TBase>
zfclassNotPOD zftIsTypeOf<TChild, TBase, false> {
public:
    enum {
        Value = zftIsSame<TChild, TBase>::Value
    };
};

template<typename T>
zfclassNotPOD zftIsTypeOf<T, T, true> {
public:
    enum {
        Value = 1
    };
};
 
// ============================================================
template<typename T_Type>
zfclassNotPOD zftIsPOD {
public:
    enum {
        Value = !zftIsClass<T_Type>::Value,
    };
};

template<typename T_Type>
zfclassNotPOD zftHash {
public:
    static zfidentity value(ZF_IN const T_Type &v) {
        return zfidentityCalc(v);
    }
};

template<typename T_Type>
inline zfidentity zfhash(ZF_IN const T_Type &v) {
    return zftHash<T_Type>::value(v);
}

#define ZFHASH_DECLARE(Type, action) \
 \
    template<> \
    zfclassNotPOD zftHash<Type > { \
    public: \
        static zfidentity value(ZF_IN const Type &v) { \
            action \
        } \
    }; \


#define ZFHASH_DECLARE_TEMPLATE(T_Type, Type, action) \
 \
    template<T_Type > \
    zfclassNotPOD zftHash<Type > { \
    public: \
        static zfidentity value(ZF_IN const Type &v) { \
            action \
        } \
    }; \


template<typename T_Element>
inline zfint zfcmpPOD(
        ZF_IN T_Element const &v0
        , ZF_IN T_Element const &v1
        ) {
    return zfmemcmp(&v0, &v1, sizeof(T_Element));
}

#define ZFCORE_POD_DECLARE(Type) \
    _ZFP_ZFCORE_POD_DECLARE(template<>, _ZFP_ZFCORE_POD_DECLARE_EXPAND(Type)) \
    _ZFP_ZFCORE_POD_DECLARE_COMPARER(_ZFP_ZFCORE_POD_DECLARE_EMPTY(), _ZFP_ZFCORE_POD_DECLARE_EXPAND(Type))

#define ZFCORE_POD_DECLARE_TEMPLATE(T_Type, Type) \
    _ZFP_ZFCORE_POD_DECLARE(_ZFP_ZFCORE_POD_DECLARE_EXPAND(template< T_Type >),_ZFP_ZFCORE_POD_DECLARE_EXPAND(Type)) \
    _ZFP_ZFCORE_POD_DECLARE_COMPARER(_ZFP_ZFCORE_POD_DECLARE_EXPAND(template< T_Type >), _ZFP_ZFCORE_POD_DECLARE_EXPAND(Type))

#define ZFCORE_POD_DECLARE_NO_COMPARER(Type) \
    _ZFP_ZFCORE_POD_DECLARE(template<>,_ZFP_ZFCORE_POD_DECLARE_EXPAND(Type))

#define ZFCORE_POD_DECLARE_TEMPLATE_NO_COMPARER(T_Type, Type) \
    _ZFP_ZFCORE_POD_DECLARE(_ZFP_ZFCORE_POD_DECLARE_EXPAND(template< T_Type >),_ZFP_ZFCORE_POD_DECLARE_EXPAND(Type))
 
#define _ZFP_ZFCORE_POD_DECLARE_EMPTY(...)
#define _ZFP_ZFCORE_POD_DECLARE_EXPAND(...) __VA_ARGS__
#define _ZFP_ZFCORE_POD_DECLARE(classFix, Type) \
 \
    classFix \
    zfclassNotPOD zftIsPOD<Type > { \
    public: \
        enum { \
            Value = 1, \
        }; \
    }; \
    classFix \
    zfclassNotPOD zftHash<Type > { \
    public: \
        static zfidentity value(ZF_IN const Type &v) { \
            return zfidentityCalc(v); \
        } \
    }; \

#define _ZFP_ZFCORE_POD_DECLARE_COMPARER(funcFix, Type) \
 \
    funcFix inline zfbool operator == (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) == 0;} \
    funcFix inline zfbool operator != (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) != 0;} \
    funcFix inline zfbool operator <  (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) <  0;} \
    funcFix inline zfbool operator <= (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) <= 0;} \
    funcFix inline zfbool operator >  (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) >  0;} \
    funcFix inline zfbool operator >= (ZF_IN const Type &v0, ZF_IN const Type &v1) {return zfcmpPOD(v0, v1) >= 0;} \

 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFCoreUtilTemplate_h_