[ceph.git] / ceph / src / boost / boost / parameter / macros.hpp

// Copyright David Abrahams, Daniel Wallin 2003.
// Copyright Cromwell D. Enage 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PARAMETER_MACROS_050412_HPP
#define BOOST_PARAMETER_MACROS_050412_HPP

#include <boost/parameter/config.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>

#if !defined(BOOST_NO_SFINAE) && \
    !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x592))

#define BOOST_PARAMETER_MATCH_TYPE(n, param)                                 \
  , typename param::match<BOOST_PP_ENUM_PARAMS(n, T)>::type kw = param()
/**/

#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param)                            \
  , typename param::match<BOOST_PP_ENUM_PARAMS_Z(z, n, T)>::type kw = param()
/**/

#else   // SFINAE disbled, or Borland workarounds needed.

#define BOOST_PARAMETER_MATCH_TYPE(n, param) , param kw = param()
/**/

#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param) , param kw = param()
/**/

#endif  // SFINAE enabled, not Borland.

#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/cat.hpp>

#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)

#define BOOST_PARAMETER_FUN_0(z, n, params)                                  \
    BOOST_PP_TUPLE_ELEM(3, 0, params) BOOST_PP_TUPLE_ELEM(3, 1, params)()    \
    {                                                                        \
        return BOOST_PP_CAT(                                                 \
            BOOST_PP_TUPLE_ELEM(3, 1, params)                                \
          , _with_named_params                                               \
        )(BOOST_PP_TUPLE_ELEM(3, 2, params)()());                            \
    }
/**/

#include <utility>

#define BOOST_PARAMETER_FUN_DECL_PARAM(z, n, p)                              \
    ::std::forward<BOOST_PP_CAT(T, n)>(BOOST_PP_CAT(p, n))
/**/

#include <boost/preprocessor/repetition/enum.hpp>

#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params)                             \
    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)>                      \
    BOOST_PP_TUPLE_ELEM(3, 0, params)                                        \
        BOOST_PP_TUPLE_ELEM(3, 1, params)(                                   \
            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, && p)                     \
            BOOST_PARAMETER_MATCH_TYPE_Z(                                    \
                z, n, BOOST_PP_TUPLE_ELEM(3, 2, params)                      \
            )                                                                \
        )                                                                    \
    {                                                                        \
        return BOOST_PP_CAT(                                                 \
            BOOST_PP_TUPLE_ELEM(3, 1, params)                                \
          , _with_named_params                                               \
        )(                                                                   \
            kw(                                                              \
                BOOST_PP_CAT(BOOST_PP_ENUM_, z)(                             \
                    n, BOOST_PARAMETER_FUN_DECL_PARAM, p                     \
                )                                                            \
            )                                                                \
        );                                                                   \
    }
/**/

#define BOOST_PARAMETER_FUN_DECL(z, n, params)                               \
    BOOST_PP_IF(                                                             \
        n                                                                    \
      , BOOST_PARAMETER_FUN_DEFN_1                                           \
      , BOOST_PARAMETER_FUN_0                                                \
    )(z, n, params)
/**/

#else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)

#define BOOST_PARAMETER_FUN_DEFN_0(z, n, params)                             \
    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)>                      \
    BOOST_PP_TUPLE_ELEM(3, 0, params)                                        \
        BOOST_PP_TUPLE_ELEM(3, 1, params)(                                   \
            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, const& p)                 \
            BOOST_PARAMETER_MATCH_TYPE_Z(                                    \
                z, n, BOOST_PP_TUPLE_ELEM(3, 2, params)                      \
            )                                                                \
        )                                                                    \
    {                                                                        \
        return BOOST_PP_CAT(                                                 \
            BOOST_PP_TUPLE_ELEM(3, 1, params)                                \
          , _with_named_params                                               \
        )(kw(BOOST_PP_ENUM_PARAMS_Z(z, n, p)));                              \
    }
/**/

#include <boost/preprocessor/seq/seq.hpp>

#define BOOST_PARAMETER_FUN_0(z, n, seq)                                     \
    BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)))     \
    BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)))()   \
    {                                                                        \
        return BOOST_PP_CAT(                                                 \
            BOOST_PP_TUPLE_ELEM(                                             \
                3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))              \
            )                                                                \
          , _with_named_params                                               \
        )(                                                                   \
        BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))) \
        ()()                                                                 \
        );                                                                   \
    }
/**/

#include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp>
#include <boost/preprocessor/seq/size.hpp>

#define BOOST_PARAMETER_FUN_DEFN_R(r, seq)                                   \
    template <                                                               \
        BOOST_PP_ENUM_PARAMS(                                                \
            BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq))                        \
          , typename T                                                       \
        )                                                                    \
    > BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(seq))                      \
        BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq))(                   \
            BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS(                       \
                BOOST_PP_SEQ_TAIL(seq), (T)(p)                               \
            )                                                                \
            BOOST_PARAMETER_MATCH_TYPE(                                      \
                BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq))                    \
              , BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(seq))            \
            )                                                                \
        )                                                                    \
    {                                                                        \
        return BOOST_PP_CAT(                                                 \
            BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq))                \
          , _with_named_params                                               \
        )(                                                                   \
            kw(                                                              \
                BOOST_PP_ENUM_PARAMS(                                        \
                    BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), p             \
                )                                                            \
            )                                                                \
        );                                                                   \
    }
/**/

#include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp>
#include <boost/preprocessor/tuple/eat.hpp>

#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params)                             \
    BOOST_PP_IF(                                                             \
        n                                                                    \
      , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z                         \
      , BOOST_PARAMETER_FUN_0                                                \
    )(z, n, (BOOST_PARAMETER_FUN_DEFN_R)(params))
/**/

#include <boost/preprocessor/comparison/less.hpp>

#define BOOST_PARAMETER_FUN_DECL(z, n, params)                               \
    BOOST_PP_CAT(                                                            \
        BOOST_PARAMETER_FUN_DEFN_                                            \
      , BOOST_PP_LESS(                                                       \
            n                                                                \
          , BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY             \
        )                                                                    \
    )(z, n, params)
/**/

#endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING

#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>

// Generates:
//
// template <typename Params>
// ret name ## _with_named_params(Params const&);
//
// template <typename T0>
// ret name(
//     T0 && p0
//   , typename parameters::match<T0>::type kw = parameters()
// )
// {
//     return name ## _with_named_params(kw(p0));
// }
//
// template <typename T0, ..., typename T ## N>
// ret name(
//     T0 && p0, ..., TN && p ## N
//   , typename parameters::match<T0, ..., T ## N>::type kw = parameters()
// )
// {
//     return name ## _with_named_params(kw(p0, ..., p ## N));
// }
//
// template <typename Params>
// ret name ## _with_named_params(Params const&)
//
// lo and hi determine the min and max arities of the generated functions.

#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters)                \
    BOOST_PP_REPEAT_FROM_TO(                                                 \
        lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL                       \
      , (ret, name, parameters)                                              \
    )                                                                        \
    template <typename Params>                                               \
    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
/**/

#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters)                   \
    template <typename Params>                                               \
    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p);             \
    BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters)
/**/

#endif  // include guard
Commit	Line	Data
92f5a8d4 TL	1	// Copyright David Abrahams, Daniel Wallin 2003.
	2	// Copyright Cromwell D. Enage 2017.
	3	// Distributed under the Boost Software License, Version 1.0.
	4	// (See accompanying file LICENSE_1_0.txt or copy at
7c673cae FG	5	// http://www.boost.org/LICENSE_1_0.txt)
	6
	7	#ifndef BOOST_PARAMETER_MACROS_050412_HPP
	8	#define BOOST_PARAMETER_MACROS_050412_HPP
	9
92f5a8d4	10	#include <boost/parameter/config.hpp>
7c673cae	11	#include <boost/preprocessor/repetition/enum_params.hpp>
92f5a8d4 TL	12
92f5a8d4 TL	13	#if !defined(BOOST_NO_SFINAE) && \
20effc67	14	!BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x592))
92f5a8d4 TL	15
	16	#define BOOST_PARAMETER_MATCH_TYPE(n, param) \
	17	, typename param::match<BOOST_PP_ENUM_PARAMS(n, T)>::type kw = param()
	18	/**/
	19
	20	#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param) \
	21	, typename param::match<BOOST_PP_ENUM_PARAMS_Z(z, n, T)>::type kw = param()
	22	/**/
	23
	24	#else // SFINAE disbled, or Borland workarounds needed.
	25
	26	#define BOOST_PARAMETER_MATCH_TYPE(n, param) , param kw = param()
	27	/**/
	28
	29	#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param) , param kw = param()
	30	/**/
	31
	32	#endif // SFINAE enabled, not Borland.
	33
	34	#include <boost/preprocessor/control/if.hpp>
7c673cae	35	#include <boost/preprocessor/repetition/enum_binary_params.hpp>
92f5a8d4	36	#include <boost/preprocessor/tuple/elem.hpp>
7c673cae	37	#include <boost/preprocessor/cat.hpp>
92f5a8d4 TL	38
	39	#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
	40
	41	#define BOOST_PARAMETER_FUN_0(z, n, params) \
	42	BOOST_PP_TUPLE_ELEM(3, 0, params) BOOST_PP_TUPLE_ELEM(3, 1, params)() \
	43	{ \
	44	return BOOST_PP_CAT( \
	45	BOOST_PP_TUPLE_ELEM(3, 1, params) \
	46	, _with_named_params \
	47	)(BOOST_PP_TUPLE_ELEM(3, 2, params)()()); \
	48	}
	49	/**/
	50
	51	#include <utility>
	52
	53	#define BOOST_PARAMETER_FUN_DECL_PARAM(z, n, p) \
	54	::std::forward<BOOST_PP_CAT(T, n)>(BOOST_PP_CAT(p, n))
	55	/**/
	56
	57	#include <boost/preprocessor/repetition/enum.hpp>
	58
	59	#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params) \
	60	template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)> \
	61	BOOST_PP_TUPLE_ELEM(3, 0, params) \
	62	BOOST_PP_TUPLE_ELEM(3, 1, params)( \
	63	BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, && p) \
	64	BOOST_PARAMETER_MATCH_TYPE_Z( \
	65	z, n, BOOST_PP_TUPLE_ELEM(3, 2, params) \
	66	) \
	67	) \
	68	{ \
	69	return BOOST_PP_CAT( \
	70	BOOST_PP_TUPLE_ELEM(3, 1, params) \
	71	, _with_named_params \
	72	)( \
	73	kw( \
	74	BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \
	75	n, BOOST_PARAMETER_FUN_DECL_PARAM, p \
	76	) \
	77	) \
	78	); \
7c673cae	79	}
92f5a8d4 TL	80	/**/
	81
	82	#define BOOST_PARAMETER_FUN_DECL(z, n, params) \
	83	BOOST_PP_IF( \
	84	n \
	85	, BOOST_PARAMETER_FUN_DEFN_1 \
	86	, BOOST_PARAMETER_FUN_0 \
	87	)(z, n, params)
	88	/**/
	89
	90	#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
	91
	92	#define BOOST_PARAMETER_FUN_DEFN_0(z, n, params) \
	93	template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)> \
	94	BOOST_PP_TUPLE_ELEM(3, 0, params) \
	95	BOOST_PP_TUPLE_ELEM(3, 1, params)( \
	96	BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, const& p) \
	97	BOOST_PARAMETER_MATCH_TYPE_Z( \
	98	z, n, BOOST_PP_TUPLE_ELEM(3, 2, params) \
	99	) \
	100	) \
	101	{ \
	102	return BOOST_PP_CAT( \
	103	BOOST_PP_TUPLE_ELEM(3, 1, params) \
	104	, _with_named_params \
	105	)(kw(BOOST_PP_ENUM_PARAMS_Z(z, n, p))); \
	106	}
	107	/**/
	108
	109	#include <boost/preprocessor/seq/seq.hpp>
	110
	111	#define BOOST_PARAMETER_FUN_0(z, n, seq) \
	112	BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))) \
	113	BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)))() \
	114	{ \
	115	return BOOST_PP_CAT( \
	116	BOOST_PP_TUPLE_ELEM( \
	117	3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \
	118	) \
	119	, _with_named_params \
	120	)( \
	121	BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))) \
	122	()() \
	123	); \
	124	}
	125	/**/
	126
	127	#include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp>
	128	#include <boost/preprocessor/seq/size.hpp>
	129
	130	#define BOOST_PARAMETER_FUN_DEFN_R(r, seq) \
	131	template < \
	132	BOOST_PP_ENUM_PARAMS( \
	133	BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \
	134	, typename T \
	135	) \
	136	> BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(seq)) \
	137	BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq))( \
	138	BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \
	139	BOOST_PP_SEQ_TAIL(seq), (T)(p) \
	140	) \
	141	BOOST_PARAMETER_MATCH_TYPE( \
	142	BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \
	143	, BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(seq)) \
144	) \
145	) \
146	{ \
147	return BOOST_PP_CAT( \
148	BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq)) \
149	, _with_named_params \
150	)( \
151	kw( \
152	BOOST_PP_ENUM_PARAMS( \
153	BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), p \
154	) \
155	) \
156	); \
157	}
158	/**/
159
160	#include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp>
161	#include <boost/preprocessor/tuple/eat.hpp>
162
163	#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params) \
164	BOOST_PP_IF( \
165	n \
166	, BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z \
167	, BOOST_PARAMETER_FUN_0 \
168	)(z, n, (BOOST_PARAMETER_FUN_DEFN_R)(params))
169	/**/
170
171	#include <boost/preprocessor/comparison/less.hpp>
172
173	#define BOOST_PARAMETER_FUN_DECL(z, n, params) \
174	BOOST_PP_CAT( \
175	BOOST_PARAMETER_FUN_DEFN_ \
176	, BOOST_PP_LESS( \
177	n \
178	, BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY \
179	) \
180	)(z, n, params)
181	/**/
182
183	#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
184
185	#include <boost/preprocessor/arithmetic/inc.hpp>
186	#include <boost/preprocessor/repetition/repeat_from_to.hpp>
7c673cae FG	187
	188	// Generates:
	189	//
92f5a8d4	190	// template <typename Params>
7c673cae FG	191	// ret name ## _with_named_params(Params const&);
7c673cae FG	192	//
92f5a8d4 TL	193	// template <typename T0>
	194	// ret name(
	195	// T0 && p0
	196	// , typename parameters::match<T0>::type kw = parameters()
	197	// )
7c673cae FG	198	// {
	199	// return name ## _with_named_params(kw(p0));
	200	// }
	201	//
92f5a8d4 TL	202	// template <typename T0, ..., typename T ## N>
	203	// ret name(
	204	// T0 && p0, ..., TN && p ## N
	205	// , typename parameters::match<T0, ..., T ## N>::type kw = parameters()
	206	// )
7c673cae	207	// {
92f5a8d4	208	// return name ## _with_named_params(kw(p0, ..., p ## N));
7c673cae FG	209	// }
7c673cae FG	210	//
92f5a8d4	211	// template <typename Params>
7c673cae FG	212	// ret name ## _with_named_params(Params const&)
7c673cae FG	213	//
92f5a8d4	214	// lo and hi determine the min and max arities of the generated functions.
7c673cae	215
92f5a8d4 TL	216	#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters) \
	217	BOOST_PP_REPEAT_FROM_TO( \
	218	lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL \
	219	, (ret, name, parameters) \
	220	) \
	221	template <typename Params> \
7c673cae	222	ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
92f5a8d4 TL	223	/**/
	224
	225	#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters) \
	226	template <typename Params> \
	227	ret BOOST_PP_CAT(name, _with_named_params)(Params const& p); \
	228	BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters)
	229	/**/
7c673cae	230
92f5a8d4	231	#endif // include guard
7c673cae	232