[ceph.git] / ceph / src / boost / libs / local_function / include / boost / local_function / aux_ / macro / name.hpp


// Copyright (C) 2009-2012 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0
// (see accompanying file LICENSE_1_0.txt or a copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Home at http://www.boost.org/libs/local_function

#ifndef BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_
#define BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_

#include <boost/local_function/config.hpp>
#include <boost/local_function/aux_/macro/decl.hpp>
#include <boost/local_function/aux_/macro/code_/functor.hpp>
#include <boost/local_function/detail/preprocessor/keyword/recursive.hpp>
#include <boost/local_function/detail/preprocessor/keyword/inline.hpp>
#include <boost/local_function/aux_/function.hpp>
#include <boost/local_function/aux_/symbol.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/logical/bitor.hpp>
#include <boost/preprocessor/tuple/eat.hpp>

// PRIVATE //

#define BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
    BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_type)(local_function_name) )

#define BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_ \
    BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (init_recursion) )

#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_( \
        is_recursive, local_function_name) \
    BOOST_PP_IIF(is_recursive, \
        local_function_name \
    , \
        BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (nonrecursive_local_function_name) ) \
    )

#define BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
        local_function_name, is_recursive, \
        local_functor_name, nonlocal_functor_name) \
    /* FUNCTION macro expanded to: typedef class functor ## __LINE__ { ... */ \
    BOOST_PP_EXPR_IIF(is_recursive, \
        /* member var with function name for recursive calls; it cannot be */ \
        /* `const` because it is init after construction (because */ \
        /* constructor doesn't know local function name) */ \
        /* run-time: even when optimizing, recursive calls cannot be */ \
        /* optimized (i.e., they must be via the non-local functor) */ \
        /* because this cannot be a mem ref because its name is not known */ \
        /* by the constructor so it cannot be set by the mem init list */ \
    private: \
        BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
                BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_(is_recursive, \
                        local_function_name); \
        /* run-time: the `init_recursion()` function cannot be called */ \
        /* by the constructor to allow for compiler optimization */ \
        /* (inlining) so it must be public to be called (see below) */ \
    public: \
        inline void BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
                BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE& functor) { \
            local_function_name = functor; \
        } \
    ) \
    } BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name); \
    /* local functor can be passed as tparam only on C++11 (faster) */ \
    BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
            local_functor_name(BOOST_LOCAL_FUNCTION_AUX_DECL_ARGS_VAR.value); \
    /* non-local functor can always be passed as tparam (but slower) */ \
    BOOST_PP_EXPR_IIF(typename01, typename) \
    BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name):: \
            BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
            nonlocal_functor_name; /* functor variable */ \
    /* the order of the following 2 function calls cannot be changed */ \
    /* because init_recursion uses the local_functor so the local_functor */ \
    /* must be init first */ \
    local_functor_name.BOOST_LOCAL_FUNCTION_AUX_FUNCTION_INIT_CALL_FUNC( \
            &local_functor_name, nonlocal_functor_name); \
    BOOST_PP_EXPR_IIF(is_recursive, \
        /* init recursion causes MSVC to not optimize local function not */ \
        /* even when local functor is used as template parameter so no */ \
        /* recursion unless all inlining optimizations are specified off */ \
        local_functor_name.BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
                nonlocal_functor_name); \
    )

#define BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name) \
    BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_function_name) )

// This can always be passed as a template parameters (on all compilers).
// However, it is slower because it cannot be inlined.
// Passed at tparam: Yes (on all C++). Inlineable: No. Recursive: No.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_(typename01, local_function_name) \
    BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
            local_function_name, \
            /* local function is not recursive (because recursion and its */ \
            /* initialization cannot be inlined even on C++11, */ \
            /* so this allows optimization at least on C++11) */ \
            0 /* not recursive */ , \
            /* local functor */ \
            BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
            /* local function declared as non-local functor -- but it can */ \
            /* be inlined only by C++11 and it cannot be recursive */ \
            local_function_name)

// This is faster on some compilers but not all (e.g., it is faster on GCC
// because its optimization inlines it but not on MSVC). However, it cannot be
// passed as a template parameter on non C++11 compilers.
// Passed at tparam: Only on C++11. Inlineable: Yes. Recursive: No.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_(typename01, local_function_name) \
    BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
            local_function_name, \
            /* inlined local function is never recursive (because recursion */ \
            /* and its initialization cannot be inlined)*/ \
            0 /* not recursive */ , \
            /* inlined local function declared as local functor (maybe */ \
            /* inlined even by non C++11 -- but it can be passed as */ \
            /* template parameter only on C++11 */ \
            local_function_name, \
            /* non-local functor */ \
            BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name))

// This is slower on all compilers (C++11 and non) because recursion and its
// initialization can never be inlined.
// Passed at tparam: Yes. Inlineable: No. Recursive: Yes.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_( \
        typename01, local_function_name) \
    BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
            local_function_name, \
            /* recursive local function -- but it cannot be inlined */ \
            1 /* recursive */ , \
            /* local functor */ \
            BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
            /* local function declared as non-local functor -- but it can */ \
            /* be inlined only by C++11 */ \
            local_function_name)

// Inlined local functions are specified by `..._NAME(inline name)`.
// They have more chances to be inlined for faster run-times by some compilers
// (for example by GCC but not by MSVC). C++11 compilers can always inline
// local functions even if they are not explicitly specified inline.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_( \
        typename01, qualified_name) \
    BOOST_PP_IIF(BOOST_PP_BITOR( \
            BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS, \
            BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_INLINE_FRONT( \
                    qualified_name)), \
        /* on C++11 always use inlining because compilers might optimize */ \
        /* it to be faster and it can also be passed as tparam */ \
        BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_ \
    , \
        /* on non C++11 don't use liniling unless explicitly specified by */ \
        /* programmers `inline name` the inlined local function cannot be */ \
        /* passed as tparam */ \
        BOOST_LOCAL_FUNCTION_AUX_NAME_ \
    )(typename01, BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
            qualified_name))

// Expand to 1 iff `recursive name` or `recursive inline name` or
// `inline recursive name`.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name) \
    BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_RECURSIVE_FRONT( \
    BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
        qualified_name \
    ))

// Revmoes `recursive`, `inline recursive`, and `recursive inline` from front.
#define BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_( \
        qualified_name) \
    BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
    BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
    BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
        qualified_name \
    )))

#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name) \
    BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
        BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_ \
    , \
        qualified_name /* might be `name` or `inline name` */ \
        BOOST_PP_TUPLE_EAT(1) \
    )(qualified_name)

// Recursive local function are specified by `..._NAME(recursive name)`. 
// They can never be inlined for faster run-time (not even by C++11 compilers).
#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_( \
        typename01, qualified_name) \
    BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
        /* recursion can never be inlined (not even on C++11) */ \
        BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_ \
    , \
        BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_ \
    )(typename01, \
            BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name))

// PUBLIC //

#define BOOST_LOCAL_FUNCTION_AUX_NAME(typename01, qualified_name) \
    BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_(typename01, qualified_name)

#endif // #include guard
Commit	Line	Data
7c673cae FG	1
	2	// Copyright (C) 2009-2012 Lorenzo Caminiti
	3	// Distributed under the Boost Software License, Version 1.0
	4	// (see accompanying file LICENSE_1_0.txt or a copy at
	5	// http://www.boost.org/LICENSE_1_0.txt)
	6	// Home at http://www.boost.org/libs/local_function
	7
	8	#ifndef BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_
	9	#define BOOST_LOCAL_FUNCTION_AUX_NAME_HPP_
	10
	11	#include <boost/local_function/config.hpp>
	12	#include <boost/local_function/aux_/macro/decl.hpp>
	13	#include <boost/local_function/aux_/macro/code_/functor.hpp>
	14	#include <boost/local_function/detail/preprocessor/keyword/recursive.hpp>
	15	#include <boost/local_function/detail/preprocessor/keyword/inline.hpp>
	16	#include <boost/local_function/aux_/function.hpp>
	17	#include <boost/local_function/aux_/symbol.hpp>
	18	#include <boost/preprocessor/control/iif.hpp>
	19	#include <boost/preprocessor/control/expr_iif.hpp>
	20	#include <boost/preprocessor/logical/bitor.hpp>
	21	#include <boost/preprocessor/tuple/eat.hpp>
	22
	23	// PRIVATE //
	24
	25	#define BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
	26	BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_type)(local_function_name) )
	27
	28	#define BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_ \
	29	BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (init_recursion) )
	30
	31	#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_( \
	32	is_recursive, local_function_name) \
	33	BOOST_PP_IIF(is_recursive, \
	34	local_function_name \
	35	, \
	36	BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (nonrecursive_local_function_name) ) \
	37	)
	38
	39	#define BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
	40	local_function_name, is_recursive, \
	41	local_functor_name, nonlocal_functor_name) \
	42	/* FUNCTION macro expanded to: typedef class functor ## __LINE__ { ... */ \
	43	BOOST_PP_EXPR_IIF(is_recursive, \
	44	/* member var with function name for recursive calls; it cannot be */ \
	45	/* `const` because it is init after construction (because */ \
	46	/* constructor doesn't know local function name) */ \
	47	/* run-time: even when optimizing, recursive calls cannot be */ \
	48	/* optimized (i.e., they must be via the non-local functor) */ \
	49	/* because this cannot be a mem ref because its name is not known */ \
	50	/* by the constructor so it cannot be set by the mem init list */ \
	51	private: \
	52	BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
	53	BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_FUNC_(is_recursive, \
	54	local_function_name); \
	55	/* run-time: the `init_recursion()` function cannot be called */ \
	56	/* by the constructor to allow for compiler optimization */ \
	57	/* (inlining) so it must be public to be called (see below) */ \
	58	public: \
	59	inline void BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
	60	BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE& functor) { \
	61	local_function_name = functor; \
	62	} \
	63	) \
	64	} BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name); \
65	/* local functor can be passed as tparam only on C++11 (faster) */ \
66	BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name) \
67	local_functor_name(BOOST_LOCAL_FUNCTION_AUX_DECL_ARGS_VAR.value); \
68	/* non-local functor can always be passed as tparam (but slower) */ \
69	BOOST_PP_EXPR_IIF(typename01, typename) \
70	BOOST_LOCAL_FUNCTION_AUX_NAME_LOCAL_TYPE_(local_function_name):: \
71	BOOST_LOCAL_FUNCTION_AUX_CODE_FUNCTOR_TYPE \
72	nonlocal_functor_name; /* functor variable */ \
73	/* the order of the following 2 function calls cannot be changed */ \
74	/* because init_recursion uses the local_functor so the local_functor */ \
75	/* must be init first */ \
76	local_functor_name.BOOST_LOCAL_FUNCTION_AUX_FUNCTION_INIT_CALL_FUNC( \
77	&local_functor_name, nonlocal_functor_name); \
78	BOOST_PP_EXPR_IIF(is_recursive, \
79	/* init recursion causes MSVC to not optimize local function not */ \
80	/* even when local functor is used as template parameter so no */ \
81	/* recursion unless all inlining optimizations are specified off */ \
82	local_functor_name.BOOST_LOCAL_FUNCTION_AUX_NAME_INIT_RECURSION_FUNC_( \
83	nonlocal_functor_name); \
84	)
85
86	#define BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name) \
87	BOOST_LOCAL_FUNCTION_AUX_SYMBOL( (local_function_name) )
88
89	// This can always be passed as a template parameters (on all compilers).
90	// However, it is slower because it cannot be inlined.
91	// Passed at tparam: Yes (on all C++). Inlineable: No. Recursive: No.
92	#define BOOST_LOCAL_FUNCTION_AUX_NAME_(typename01, local_function_name) \
93	BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
94	local_function_name, \
95	/* local function is not recursive (because recursion and its */ \
96	/* initialization cannot be inlined even on C++11, */ \
97	/* so this allows optimization at least on C++11) */ \
98	0 /* not recursive */ , \
99	/* local functor */ \
100	BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
101	/* local function declared as non-local functor -- but it can */ \
102	/* be inlined only by C++11 and it cannot be recursive */ \
103	local_function_name)
104
105	// This is faster on some compilers but not all (e.g., it is faster on GCC
106	// because its optimization inlines it but not on MSVC). However, it cannot be
107	// passed as a template parameter on non C++11 compilers.
108	// Passed at tparam: Only on C++11. Inlineable: Yes. Recursive: No.
109	#define BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_(typename01, local_function_name) \
110	BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
111	local_function_name, \
112	/* inlined local function is never recursive (because recursion */ \
113	/* and its initialization cannot be inlined)*/ \
114	0 /* not recursive */ , \
115	/* inlined local function declared as local functor (maybe */ \
116	/* inlined even by non C++11 -- but it can be passed as */ \
117	/* template parameter only on C++11 */ \
118	local_function_name, \
119	/* non-local functor */ \
120	BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name))
121
122	// This is slower on all compilers (C++11 and non) because recursion and its
123	// initialization can never be inlined.
124	// Passed at tparam: Yes. Inlineable: No. Recursive: Yes.
125	#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_( \
126	typename01, local_function_name) \
127	BOOST_LOCAL_FUNCTION_AUX_NAME_END_LOCAL_FUNCTOR_(typename01, \
128	local_function_name, \
129	/* recursive local function -- but it cannot be inlined */ \
130	1 /* recursive */ , \
131	/* local functor */ \
132	BOOST_LOCAL_FUNCTION_AUX_NAME_FUNCTOR_(local_function_name), \
133	/* local function declared as non-local functor -- but it can */ \
134	/* be inlined only by C++11 */ \
135	local_function_name)
136
137	// Inlined local functions are specified by `..._NAME(inline name)`.
138	// They have more chances to be inlined for faster run-times by some compilers
139	// (for example by GCC but not by MSVC). C++11 compilers can always inline
140	// local functions even if they are not explicitly specified inline.
141	#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_( \
142	typename01, qualified_name) \
143	BOOST_PP_IIF(BOOST_PP_BITOR( \
144	BOOST_LOCAL_FUNCTION_CONFIG_LOCALS_AS_TPARAMS, \
145	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_INLINE_FRONT( \
146	qualified_name)), \
147	/* on C++11 always use inlining because compilers might optimize */ \
148	/* it to be faster and it can also be passed as tparam */ \
149	BOOST_LOCAL_FUNCTION_AUX_NAME_INLINE_ \
150	, \
151	/* on non C++11 don't use liniling unless explicitly specified by */ \
152	/* programmers `inline name` the inlined local function cannot be */ \
153	/* passed as tparam */ \
154	BOOST_LOCAL_FUNCTION_AUX_NAME_ \
155	)(typename01, BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
156	qualified_name))
157
158	// Expand to 1 iff `recursive name` or `recursive inline name` or
159	// `inline recursive name`.
160	#define BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name) \
161	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_RECURSIVE_FRONT( \
162	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
163	qualified_name \
164	))
165
166	// Revmoes `recursive`, `inline recursive`, and `recursive inline` from front.
167	#define BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_( \
168	qualified_name) \
169	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
170	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_INLINE_REMOVE_FRONT( \
171	BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_RECURSIVE_REMOVE_FRONT( \
172	qualified_name \
173	)))
174
175	#define BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name) \
176	BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
177	BOOST_LOCAL_FUNCTION_AUX_NAME_REMOVE_RECURSIVE_AND_INLINE_ \
178	, \
179	qualified_name /* might be `name` or `inline name` */ \
180	BOOST_PP_TUPLE_EAT(1) \
181	)(qualified_name)
182
183	// Recursive local function are specified by `..._NAME(recursive name)`.
184	// They can never be inlined for faster run-time (not even by C++11 compilers).
185	#define BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_( \
186	typename01, qualified_name) \
187	BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_AUX_NAME_IS_RECURSIVE_(qualified_name), \
188	/* recursion can never be inlined (not even on C++11) */ \
189	BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_ \
190	, \
191	BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_INLINE_ \
192	)(typename01, \
193	BOOST_LOCAL_FUNCTION_AUX_NAME_RECURSIVE_REMOVE_(qualified_name))
194
195	// PUBLIC //
196
197	#define BOOST_LOCAL_FUNCTION_AUX_NAME(typename01, qualified_name) \
198	BOOST_LOCAL_FUNCTION_AUX_NAME_PARSE_RECURSIVE_(typename01, qualified_name)
199
200	#endif // #include guard
201