ZFCoreUtilMacro.h

Go to the documentation of this file.

#ifndef _ZFI_ZFCoreUtilMacro_h_
#define _ZFI_ZFCoreUtilMacro_h_
 
#include "ZFCoreTypeDef.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
#define ZFBitTest(var, bit) (((var) & (bit)) != 0)
#define ZFBitTestAll(var, bit) (((var) & (bit)) == (bit))
#define ZFBitGet(var, bit) ((var) & (bit))
#define ZFBitSet(var, bit) ((var) |= (bit))
#define ZFBitUnset(var, bit) ((var) &= (~(bit)))
 
// ============================================================
#define ZF_HINT(...)
 
// ============================================================
#define _ZFP_ZFM_REPEAT_0(Type, LeftCommaFix, CenterCommaFix)
#define _ZFP_ZFM_REPEAT_1(Type, LeftCommaFix, CenterCommaFix) LeftCommaFix() Type(0)
#define _ZFP_ZFM_REPEAT_2(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_1(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(1)
#define _ZFP_ZFM_REPEAT_3(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_2(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(2)
#define _ZFP_ZFM_REPEAT_4(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_3(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(3)
#define _ZFP_ZFM_REPEAT_5(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_4(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(4)
#define _ZFP_ZFM_REPEAT_6(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_5(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(5)
#define _ZFP_ZFM_REPEAT_7(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_6(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(6)
#define _ZFP_ZFM_REPEAT_8(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_7(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(7)
#define _ZFP_ZFM_REPEAT_9(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_8(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(8)
#define _ZFP_ZFM_REPEAT_10(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_9(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(9)
#define _ZFP_ZFM_REPEAT_11(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_10(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(10)
#define _ZFP_ZFM_REPEAT_12(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_11(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(11)
#define _ZFP_ZFM_REPEAT_13(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_12(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(12)
#define _ZFP_ZFM_REPEAT_14(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_13(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(13)
#define _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_14(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(14)
#define _ZFP_ZFM_REPEAT_16(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(15)
#define _ZFP_ZFM_REPEAT_17(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(16)
#define _ZFP_ZFM_REPEAT_18(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(17)
#define _ZFP_ZFM_REPEAT_19(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(18)
#define _ZFP_ZFM_REPEAT_20(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(19)
#define _ZFP_ZFM_REPEAT_21(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(20)
#define _ZFP_ZFM_REPEAT_22(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(21)
#define _ZFP_ZFM_REPEAT_23(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(22)
#define _ZFP_ZFM_REPEAT_24(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(23)
#define _ZFP_ZFM_REPEAT_25(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(24)
#define _ZFP_ZFM_REPEAT_26(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(25)
#define _ZFP_ZFM_REPEAT_27(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(26)
#define _ZFP_ZFM_REPEAT_28(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(27)
#define _ZFP_ZFM_REPEAT_29(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(28)
#define _ZFP_ZFM_REPEAT_30(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(29)
#define _ZFP_ZFM_REPEAT_31(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(30)
#define _ZFP_ZFM_REPEAT_32(Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_15(Type, LeftCommaFix, CenterCommaFix) CenterCommaFix() Type(31)
#define _ZFP_ZFM_REPEAT(N, Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT_##N(Type, LeftCommaFix, CenterCommaFix)
#define ZFM_REPEAT(N, Type, LeftCommaFix, CenterCommaFix) _ZFP_ZFM_REPEAT(N, Type, LeftCommaFix, CenterCommaFix)
 
#define _ZFP_ZFM_REPEAT_TEMPLATE(N) typename Type##N
#define _ZFP_ZFM_REPEAT_TYPE(N) Type##N
#define _ZFP_ZFM_REPEAT_TYPE_CONST(N) Type##N const &
#define _ZFP_ZFM_REPEAT_NAME(N) param##N
#define _ZFP_ZFM_REPEAT_PARAM(N) Type##N param##N

#define ZFM_REPEAT_TEMPLATE(N) _ZFP_ZFM_REPEAT_TEMPLATE(N)
#define ZFM_REPEAT_TYPE(N) _ZFP_ZFM_REPEAT_TYPE(N)
#define ZFM_REPEAT_TYPE_CONST(N) _ZFP_ZFM_REPEAT_TYPE_CONST(N)
#define ZFM_REPEAT_NAME(N) _ZFP_ZFM_REPEAT_NAME(N)
#define ZFM_REPEAT_PARAM(N) _ZFP_ZFM_REPEAT_PARAM(N)
 
// ============================================================
#define ZFM_BRACKET_L() (
#define ZFM_BRACKET_R() )

#define ZFM_EMPTY(...)
#define ZFM_COMMA() ,

#define ZFM_EXPAND(...) __VA_ARGS__

#define ZFM_CAT(a, b) _ZFP_ZFM_CAT(a, b)
#define _ZFP_ZFM_CAT(a, b) a##b

#define ZFM_TOSTRING(a) _ZFP_ZFM_TOSTRING(a)
#define _ZFP_ZFM_TOSTRING(a) #a
 
// ============================================================
#define _ZFP_ZFM_N_INC_T(n) _ZFP_ZFM_N_INC_##n
#define _ZFP_ZFM_N_INC_0 1
#define _ZFP_ZFM_N_INC_1 2
#define _ZFP_ZFM_N_INC_2 3
#define _ZFP_ZFM_N_INC_3 4
#define _ZFP_ZFM_N_INC_4 5
#define _ZFP_ZFM_N_INC_5 6
#define _ZFP_ZFM_N_INC_6 7
#define _ZFP_ZFM_N_INC_7 8
#define _ZFP_ZFM_N_INC_8 9
#define _ZFP_ZFM_N_INC_9 10
#define _ZFP_ZFM_N_INC_10 11
#define _ZFP_ZFM_N_INC_11 12
#define _ZFP_ZFM_N_INC_12 13
#define _ZFP_ZFM_N_INC_13 14
#define _ZFP_ZFM_N_INC_14 15
#define _ZFP_ZFM_N_INC_15 16
#define _ZFP_ZFM_N_INC_16 17
#define _ZFP_ZFM_N_INC_17 18
#define _ZFP_ZFM_N_INC_18 19
#define _ZFP_ZFM_N_INC_19 20
#define _ZFP_ZFM_N_INC_20 21
#define _ZFP_ZFM_N_INC_21 22
#define _ZFP_ZFM_N_INC_22 23
#define _ZFP_ZFM_N_INC_23 24
#define _ZFP_ZFM_N_INC_24 25
#define _ZFP_ZFM_N_INC_25 26
#define _ZFP_ZFM_N_INC_26 27
#define _ZFP_ZFM_N_INC_27 28
#define _ZFP_ZFM_N_INC_28 29
#define _ZFP_ZFM_N_INC_29 30
#define _ZFP_ZFM_N_INC_30 31
#define _ZFP_ZFM_N_INC_31 32
#define ZFM_N_INC(n) _ZFP_ZFM_N_INC_T(n)
 
#define _ZFP_ZFM_N_DEC_T(n) _ZFP_ZFM_N_DEC_##n
#define _ZFP_ZFM_N_DEC_0 -1
#define _ZFP_ZFM_N_DEC_1 0
#define _ZFP_ZFM_N_DEC_2 1
#define _ZFP_ZFM_N_DEC_3 2
#define _ZFP_ZFM_N_DEC_4 3
#define _ZFP_ZFM_N_DEC_5 4
#define _ZFP_ZFM_N_DEC_6 5
#define _ZFP_ZFM_N_DEC_7 6
#define _ZFP_ZFM_N_DEC_8 7
#define _ZFP_ZFM_N_DEC_9 8
#define _ZFP_ZFM_N_DEC_10 9
#define _ZFP_ZFM_N_DEC_11 10
#define _ZFP_ZFM_N_DEC_12 11
#define _ZFP_ZFM_N_DEC_13 12
#define _ZFP_ZFM_N_DEC_14 13
#define _ZFP_ZFM_N_DEC_15 14
#define _ZFP_ZFM_N_DEC_16 15
#define _ZFP_ZFM_N_DEC_17 16
#define _ZFP_ZFM_N_DEC_18 17
#define _ZFP_ZFM_N_DEC_19 18
#define _ZFP_ZFM_N_DEC_20 19
#define _ZFP_ZFM_N_DEC_21 20
#define _ZFP_ZFM_N_DEC_22 21
#define _ZFP_ZFM_N_DEC_23 22
#define _ZFP_ZFM_N_DEC_24 23
#define _ZFP_ZFM_N_DEC_25 24
#define _ZFP_ZFM_N_DEC_26 25
#define _ZFP_ZFM_N_DEC_27 26
#define _ZFP_ZFM_N_DEC_28 27
#define _ZFP_ZFM_N_DEC_29 28
#define _ZFP_ZFM_N_DEC_30 29
#define _ZFP_ZFM_N_DEC_31 30
#define _ZFP_ZFM_N_DEC_32 31
#define ZFM_N_DEC(n) _ZFP_ZFM_N_DEC_T(n)
 
#define _ZFP_ZFM_PARAM_EXPAND(...) __VA_ARGS__
#define ZFM_PARAM_NUM(...) \
    _ZFP_ZFM_PARAM_EXPAND(_ZFP_ZFM_PARAM_NUM_TMP0(__VA_ARGS__, _ZFP_ZFM_PARAM_NUM_TMP2()))
#define _ZFP_ZFM_PARAM_NUM_TMP0(...) \
    _ZFP_ZFM_PARAM_EXPAND(_ZFP_ZFM_PARAM_NUM_TMP1(__VA_ARGS__))
#define _ZFP_ZFM_PARAM_NUM_TMP1(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, N, ...) \
    N
#define _ZFP_ZFM_PARAM_NUM_TMP2() \
    32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define ZFM_FIX_PARAM(ParamFix, commaFix, ...) \
    _ZFP_ZFM_FIX_PARAM_CALL_01(_ZFP_ZFM_FIX_PARAM_N(_0, ##__VA_ARGS__ \
            , _ZFP_ZFM_FIX_PARAM_E_33, _ZFP_ZFM_FIX_PARAM_E_32, _ZFP_ZFM_FIX_PARAM_E_31, _ZFP_ZFM_FIX_PARAM_E_30 \
            , _ZFP_ZFM_FIX_PARAM_E_29, _ZFP_ZFM_FIX_PARAM_E_28, _ZFP_ZFM_FIX_PARAM_E_27, _ZFP_ZFM_FIX_PARAM_E_26, _ZFP_ZFM_FIX_PARAM_E_25 \
            , _ZFP_ZFM_FIX_PARAM_E_24, _ZFP_ZFM_FIX_PARAM_E_23, _ZFP_ZFM_FIX_PARAM_E_22, _ZFP_ZFM_FIX_PARAM_E_21, _ZFP_ZFM_FIX_PARAM_E_20 \
            , _ZFP_ZFM_FIX_PARAM_E_19, _ZFP_ZFM_FIX_PARAM_E_18, _ZFP_ZFM_FIX_PARAM_E_17, _ZFP_ZFM_FIX_PARAM_E_16, _ZFP_ZFM_FIX_PARAM_E_15 \
            , _ZFP_ZFM_FIX_PARAM_E_14, _ZFP_ZFM_FIX_PARAM_E_13, _ZFP_ZFM_FIX_PARAM_E_12, _ZFP_ZFM_FIX_PARAM_E_11, _ZFP_ZFM_FIX_PARAM_E_10 \
            , _ZFP_ZFM_FIX_PARAM_E_09, _ZFP_ZFM_FIX_PARAM_E_08, _ZFP_ZFM_FIX_PARAM_E_07, _ZFP_ZFM_FIX_PARAM_E_06, _ZFP_ZFM_FIX_PARAM_E_05 \
            , _ZFP_ZFM_FIX_PARAM_E_04, _ZFP_ZFM_FIX_PARAM_E_03, _ZFP_ZFM_FIX_PARAM_E_02, _ZFP_ZFM_FIX_PARAM_E_01, _ZFP_ZFM_FIX_PARAM_E_00 \
        ), (ParamFix, commaFix, ##__VA_ARGS__))
 
#define _ZFP_ZFM_FIX_PARAM_CALL_01(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_02(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_03(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_04(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_04(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_05(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_06(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_07(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_08(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_09(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_10(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_11(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_12(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_13(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_14(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_15(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_16(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_17(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_18(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_19(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_20(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_21(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_22(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_23(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_24(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_25(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_26(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_27(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_28(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_29(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_30(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_31(C, v) C v
#define _ZFP_ZFM_FIX_PARAM_CALL_32(C, v) C v
 
#define _ZFP_ZFM_FIX_PARAM_E_00()
#define _ZFP_ZFM_FIX_PARAM_E_01(ParamFix, commaFix, a, ...) ParamFix(a)
#define _ZFP_ZFM_FIX_PARAM_E_02(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_02(_ZFP_ZFM_FIX_PARAM_E_01, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_03(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_03(_ZFP_ZFM_FIX_PARAM_E_02, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_04(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_04(_ZFP_ZFM_FIX_PARAM_E_03, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_05(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_05(_ZFP_ZFM_FIX_PARAM_E_04, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_06(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_06(_ZFP_ZFM_FIX_PARAM_E_05, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_07(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_07(_ZFP_ZFM_FIX_PARAM_E_06, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_08(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_08(_ZFP_ZFM_FIX_PARAM_E_07, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_09(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_09(_ZFP_ZFM_FIX_PARAM_E_08, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_10(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_10(_ZFP_ZFM_FIX_PARAM_E_09, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_11(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_11(_ZFP_ZFM_FIX_PARAM_E_10, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_12(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_12(_ZFP_ZFM_FIX_PARAM_E_11, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_13(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_13(_ZFP_ZFM_FIX_PARAM_E_12, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_14(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_14(_ZFP_ZFM_FIX_PARAM_E_13, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_15(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_15(_ZFP_ZFM_FIX_PARAM_E_14, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_16(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_16(_ZFP_ZFM_FIX_PARAM_E_15, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_17(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_17(_ZFP_ZFM_FIX_PARAM_E_16, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_18(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_18(_ZFP_ZFM_FIX_PARAM_E_17, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_19(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_19(_ZFP_ZFM_FIX_PARAM_E_18, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_20(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_20(_ZFP_ZFM_FIX_PARAM_E_19, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_21(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_21(_ZFP_ZFM_FIX_PARAM_E_20, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_22(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_22(_ZFP_ZFM_FIX_PARAM_E_21, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_23(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_23(_ZFP_ZFM_FIX_PARAM_E_22, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_24(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_24(_ZFP_ZFM_FIX_PARAM_E_23, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_25(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_25(_ZFP_ZFM_FIX_PARAM_E_24, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_26(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_26(_ZFP_ZFM_FIX_PARAM_E_25, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_27(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_27(_ZFP_ZFM_FIX_PARAM_E_26, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_28(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_28(_ZFP_ZFM_FIX_PARAM_E_27, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_29(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_29(_ZFP_ZFM_FIX_PARAM_E_28, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_30(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_30(_ZFP_ZFM_FIX_PARAM_E_29, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_31(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_31(_ZFP_ZFM_FIX_PARAM_E_30, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_32(ParamFix, commaFix, a, ...) ParamFix(a) commaFix() _ZFP_ZFM_FIX_PARAM_CALL_32(_ZFP_ZFM_FIX_PARAM_E_31, (ParamFix, commaFix, ##__VA_ARGS__))
#define _ZFP_ZFM_FIX_PARAM_E_33(...) ERROR: supports up to 32 arguments
 
#define _ZFP_ZFM_FIX_PARAM_N( \
         _00,_01,_02,_03,_04,_05,_06,_07,_08,_09 \
        ,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19 \
        ,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29 \
        ,_30,_31,_32,_33 \
    , NAME, ...) NAME
 
// ============================================================
#define ZFM_VA_APPEND(ToExpand, ToAppend, ...) \
    _ZFP_ZFM_VA_APPEND(ToExpand, _ZFP_ZFM_VA_APPEND_RM_FIRST(dummy, ##__VA_ARGS__, ToAppend))
#define _ZFP_ZFM_VA_APPEND_CALL(M, P) M P
#define _ZFP_ZFM_VA_APPEND_RM_FIRST(first, ...) __VA_ARGS__
#define _ZFP_ZFM_VA_APPEND(ToExpand, ...) _ZFP_ZFM_VA_APPEND_CALL(ToExpand, (__VA_ARGS__))
 
// ============================================================
#define _ZFP_zfidentityHash_EXPAND(v) (zfidentity)(v)
#define _ZFP_zfidentityHash_COMMA() ^
#define zfidentityHash(hash, ...) \
    (zfidentity)(ZFM_FIX_PARAM(_ZFP_zfidentityHash_EXPAND, _ZFP_zfidentityHash_COMMA, hash, ##__VA_ARGS__))
 
// ============================================================
#define ZFUNUSED(v) ((void)(v))
 
// ============================================================
#define ZFM_ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
 
// ============================================================
#define ZFUniqueName(name) _ZFP_ZFUniqueName2(name, __LINE__)
#define _ZFP_ZFUniqueName2(name, line) _ZFP_ZFUniqueName3(name, line)
#define _ZFP_ZFUniqueName3(name, line) _ZFP_uniq_##name##_##line
 
// ============================================================
#define ZFM_CLASS_HAS_MEMBER_DECLARE(NameSpace, memberName, memberSig) \
 \
    template<typename T_Owner> \
    zfclassNotPOD _ZFP_ClsHM_##NameSpace##_##memberName { \
    private: \
        template <typename T, memberSig> struct _Fix {}; \
        template<typename T> static char _has(_Fix<T, &T::memberName> *); \
        template<typename T> static int _has(...); \
    public: \
        enum { value = (sizeof(_has<T_Owner>(0)) == sizeof(char) ? 1 : 0) }; \
    }; \


#define ZFM_CLASS_HAS_MEMBER(NameSpace, memberName, ClassToCheck) \
    (_ZFP_ClsHM_##NameSpace##_##memberName<ClassToCheck>::value ? 1 : 0)
 
// ============================================================
#define ZFCORE_PARAM_DECLARE_SELF(T_self) \
    public: \
 \
        typedef T_self zfself; \
    public:

#define ZFCORE_PARAM(T_ParamType, paramName, ...) \
    _ZFP_ZFCORE_PARAM(T_ParamType, paramName, _ZFP_ZFCORE_PARAM_INIT(__VA_ARGS__))
#define _ZFP_ZFCORE_PARAM_INIT(...) __VA_ARGS__
#define _ZFP_ZFCORE_PARAM(T_ParamType, paramName, initValue) \
    public: \
        inline T_ParamType &paramName(void) { \
            return this->paramName##_PropV.value; \
        } \
 \
        inline T_ParamType const &paramName(void) const { \
            return this->paramName##_PropV.value; \
        } \
    private: \
        zfclassLikePOD paramName##_PropT { \
        public: \
            paramName##_PropT(void) \
            : value(initValue) \
            { \
            } \
            paramName##_PropT(ZF_IN const paramName##_PropT &ref) \
            : value(ref.value) \
            { \
            } \
            paramName##_PropT &operator = (ZF_IN const paramName##_PropT &ref) { \
                this->value = ref.value; \
                return *this; \
            } \
        public: \
            T_ParamType value; \
        }; \
        paramName##_PropT paramName##_PropV; \
 \
    public: \
 \
        inline zfself &paramName(ZF_IN T_ParamType const &value) { \
            this->paramName##_PropV.value = value; \
            return *this; \
        }
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFCoreUtilMacro_h_