[ceph.git] / ceph / src / boost / libs / hana / include / boost / hana / detail / struct_macros.erb.hpp

<%#
    This is an ERB [1] template file used to generate the
    <boost/hana/detail/struct_macros.hpp> header. The maximum
    number of members that can be handled by the macros can
    be controlled with the 'MAX_NUMBER_OF_MEMBERS' variable,
    which can be set when calling ERB to generate the header:

        export MAX_NUMBER_OF_MEMBERS=55; erb struct_macros.erb.hpp

    'MAX_NUMBER_OF_MEMBERS' must be <= 62, otherwise an error is triggered.
    In case 'MAX_NUMBER_OF_MEMBERS' is not specified, it defaults to 40.

    [1]: http://en.wikipedia.org/wiki/ERuby
%>

<%
    MAX_NUMBER_OF_MEMBERS = (ENV["MAX_NUMBER_OF_MEMBERS"] || 40).to_i
    raise "MAX_NUMBER_OF_MEMBERS must be <= 62" if MAX_NUMBER_OF_MEMBERS > 62
%>

/*!
@file
Defines the `BOOST_HANA_DEFINE_STRUCT`, `BOOST_HANA_ADAPT_STRUCT`, and
`BOOST_HANA_ADAPT_ADT` macros.

@copyright Louis Dionne 2013-2016
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 */

//////////////////////////////////////////////////////////////////////////////
// THIS FILE IS GENERATED FROM THE <boost/hana/detail/struct_macros.erb.hpp>
// ERB TEMPLATE. DO NOT EDIT THIS FILE DIRECTLY.
//
// THE ERB TEMPLATE CONTAINS INFORMATION ABOUT HOW TO REGENERATE THIS FILE.
//////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
#define BOOST_HANA_DETAIL_STRUCT_MACROS_HPP

#include <boost/hana/config.hpp>
#include <boost/hana/detail/preprocessor.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/tuple.hpp>

#include <cstddef>
#include <utility>


BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
    template <typename Memptr, Memptr ptr>
    struct member_ptr {
        template <typename T>
        constexpr decltype(auto) operator()(T&& t) const
        { return static_cast<T&&>(t).*ptr; }
    };

    constexpr std::size_t strlen(char const* s) {
        std::size_t n = 0;
        while (*s++ != '\0')
            ++n;
        return n;
    }

    template <std::size_t n, typename Names, std::size_t ...i>
    constexpr auto prepare_member_name_impl(std::index_sequence<i...>) {
        return hana::string_c<hana::at_c<n>(Names::get())[i]...>;
    }

    template <std::size_t n, typename Names>
    constexpr auto prepare_member_name() {
        constexpr std::size_t len = strlen(hana::at_c<n>(Names::get()));
        return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{});
    }
} BOOST_HANA_NAMESPACE_END

//////////////////////////////////////////////////////////////////////////////
// BOOST_HANA_ADAPT_STRUCT
//////////////////////////////////////////////////////////////////////////////
template <typename ...>
struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace;

#define BOOST_HANA_ADAPT_STRUCT(...)                                        \
  template <>                                                               \
  struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace<>;  \
  BOOST_HANA_ADAPT_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)\
  static_assert(true, "force the usage of a trailing semicolon")            \
/**/

#define BOOST_HANA_ADAPT_STRUCT_IMPL(N, ...) \
  BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_STRUCT_IMPL_, N)(__VA_ARGS__)

<% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
#define BOOST_HANA_ADAPT_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)    \
    namespace boost { namespace hana {                                                            \
        template <>                                                                               \
        struct accessors_impl<TYPE> {                                                             \
            static constexpr auto apply() {                                                       \
                struct member_names {                                                             \
                  static constexpr auto get() {                                                   \
                      return ::boost::hana::make_tuple(                                           \
                          <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(m#{i})" }.join(', ') %>   \
                      );                                                                          \
                  }                                                                               \
                };                                                                                \
                return ::boost::hana::make_tuple(                                                 \
                    <%= (1..n).map { |i| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m#{i}), &TYPE::m#{i}>{})" }.join(', ') %>\
                );                                                                                \
            }                                                                                     \
        };                                                                                        \
    }}                                                                                            \
/**/
<% end %>

//////////////////////////////////////////////////////////////////////////////
// BOOST_HANA_ADAPT_ADT
//////////////////////////////////////////////////////////////////////////////
template <typename ...>
struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace;

#define BOOST_HANA_ADAPT_ADT(...)                                           \
  template <>                                                               \
  struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace<>;     \
  BOOST_HANA_ADAPT_ADT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)   \
  static_assert(true, "force the usage of a trailing semicolon")            \
/**/

#define BOOST_HANA_ADAPT_ADT_IMPL(N, ...) \
  BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_ADT_IMPL_, N)(__VA_ARGS__)

<% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
#define BOOST_HANA_ADAPT_ADT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)             \
    namespace boost { namespace hana {                                                                  \
        template <>                                                                                     \
        struct accessors_impl<TYPE> {                                                                   \
            template <typename ...>                                                                     \
            static constexpr auto apply() {                                                             \
                struct member_names {                                                                   \
                  static constexpr auto get() {                                                         \
                      return ::boost::hana::make_tuple(                                                 \
                        <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m#{i})" }.join(', ') %>\
                      );                                                                                \
                  }                                                                                     \
                };                                                                                      \
                return ::boost::hana::make_tuple(                                                       \
                    <%= (1..n).map { |i| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), BOOST_HANA_PP_DROP_FRONT m#{i})" }.join(', ') %>\
                );                                                                                      \
            }                                                                                           \
        };                                                                                              \
    }}                                                                                                  \
/**/
<% end %>

//////////////////////////////////////////////////////////////////////////////
// BOOST_HANA_DEFINE_STRUCT
//////////////////////////////////////////////////////////////////////////////
#define BOOST_HANA_DEFINE_STRUCT(...) \
    BOOST_HANA_DEFINE_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)

#define BOOST_HANA_DEFINE_STRUCT_IMPL(N, ...) \
    BOOST_HANA_PP_CONCAT(BOOST_HANA_DEFINE_STRUCT_IMPL_, N)(__VA_ARGS__)

<% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
#define BOOST_HANA_DEFINE_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)       \
  <%= (1..n).map { |i| "BOOST_HANA_PP_DROP_BACK m#{i} BOOST_HANA_PP_BACK m#{i};" }.join(' ') %>       \
                                                                                                      \
  struct hana_accessors_impl {                                                                        \
    static constexpr auto apply() {                                                                   \
      struct member_names {                                                                           \
        static constexpr auto get() {                                                                 \
            return ::boost::hana::make_tuple(                                                         \
              <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m#{i})" }.join(', ') %>\
            );                                                                                        \
        }                                                                                             \
      };                                                                                              \
      return ::boost::hana::make_tuple(                                                               \
        <%= (1..n).map { |i| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m#{i}), &TYPE::BOOST_HANA_PP_BACK m#{i}>{})" }.join(', ') %>\
      );                                                                                              \
    }                                                                                                 \
  }                                                                                                   \
/**/
<% end %>

#endif // !BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
Commit	Line	Data
7c673cae FG	1	<%#
	2	This is an ERB [1] template file used to generate the
	3	<boost/hana/detail/struct_macros.hpp> header. The maximum
	4	number of members that can be handled by the macros can
	5	be controlled with the 'MAX_NUMBER_OF_MEMBERS' variable,
	6	which can be set when calling ERB to generate the header:
	7
	8	export MAX_NUMBER_OF_MEMBERS=55; erb struct_macros.erb.hpp
	9
	10	'MAX_NUMBER_OF_MEMBERS' must be <= 62, otherwise an error is triggered.
	11	In case 'MAX_NUMBER_OF_MEMBERS' is not specified, it defaults to 40.
	12
	13	[1]: http://en.wikipedia.org/wiki/ERuby
	14	%>
	15
	16	<%
	17	MAX_NUMBER_OF_MEMBERS = (ENV["MAX_NUMBER_OF_MEMBERS"] \|\| 40).to_i
	18	raise "MAX_NUMBER_OF_MEMBERS must be <= 62" if MAX_NUMBER_OF_MEMBERS > 62
	19	%>
	20
	21	/*!
	22	@file
	23	Defines the `BOOST_HANA_DEFINE_STRUCT`, `BOOST_HANA_ADAPT_STRUCT`, and
	24	`BOOST_HANA_ADAPT_ADT` macros.
	25
	26	@copyright Louis Dionne 2013-2016
	27	Distributed under the Boost Software License, Version 1.0.
	28	(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
	29	*/
	30
	31	//////////////////////////////////////////////////////////////////////////////
	32	// THIS FILE IS GENERATED FROM THE <boost/hana/detail/struct_macros.erb.hpp>
	33	// ERB TEMPLATE. DO NOT EDIT THIS FILE DIRECTLY.
	34	//
	35	// THE ERB TEMPLATE CONTAINS INFORMATION ABOUT HOW TO REGENERATE THIS FILE.
	36	//////////////////////////////////////////////////////////////////////////////
	37
	38	#ifndef BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
	39	#define BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
	40
	41	#include <boost/hana/config.hpp>
	42	#include <boost/hana/detail/preprocessor.hpp>
	43	#include <boost/hana/pair.hpp>
	44	#include <boost/hana/string.hpp>
	45	#include <boost/hana/tuple.hpp>
	46
	47	#include <cstddef>
	48	#include <utility>
	49
	50
	51	BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
	52	template <typename Memptr, Memptr ptr>
	53	struct member_ptr {
	54	template <typename T>
	55	constexpr decltype(auto) operator()(T&& t) const
	56	{ return static_cast<T&&>(t).*ptr; }
	57	};
	58
	59	constexpr std::size_t strlen(char const* s) {
	60	std::size_t n = 0;
	61	while (*s++ != '\0')
	62	++n;
	63	return n;
	64	}
65
66	template <std::size_t n, typename Names, std::size_t ...i>
67	constexpr auto prepare_member_name_impl(std::index_sequence<i...>) {
68	return hana::string_c<hana::at_c<n>(Names::get())[i]...>;
69	}
70
71	template <std::size_t n, typename Names>
72	constexpr auto prepare_member_name() {
73	constexpr std::size_t len = strlen(hana::at_c<n>(Names::get()));
74	return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{});
75	}
76	} BOOST_HANA_NAMESPACE_END
77
78	//////////////////////////////////////////////////////////////////////////////
79	// BOOST_HANA_ADAPT_STRUCT
80	//////////////////////////////////////////////////////////////////////////////
81	template <typename ...>
82	struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace;
83
84	#define BOOST_HANA_ADAPT_STRUCT(...) \
85	template <> \
86	struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace<>; \
87	BOOST_HANA_ADAPT_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)\
88	static_assert(true, "force the usage of a trailing semicolon") \
89	/**/
90
91	#define BOOST_HANA_ADAPT_STRUCT_IMPL(N, ...) \
92	BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_STRUCT_IMPL_, N)(__VA_ARGS__)
93
94	<% (0..MAX_NUMBER_OF_MEMBERS).each do \|n\| %>
95	#define BOOST_HANA_ADAPT_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { \|i\| ", m#{i}" }.join %>) \
96	namespace boost { namespace hana { \
97	template <> \
98	struct accessors_impl<TYPE> { \
99	static constexpr auto apply() { \
100	struct member_names { \
101	static constexpr auto get() { \
102	return ::boost::hana::make_tuple( \
103	<%= (1..n).map { \|i\| "BOOST_HANA_PP_STRINGIZE(m#{i})" }.join(', ') %> \
104	); \
105	} \
106	}; \
107	return ::boost::hana::make_tuple( \
108	<%= (1..n).map { \|i\| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m#{i}), &TYPE::m#{i}>{})" }.join(', ') %>\
109	); \
110	} \
111	}; \
112	}} \
113	/**/
114	<% end %>
115
116	//////////////////////////////////////////////////////////////////////////////
117	// BOOST_HANA_ADAPT_ADT
118	//////////////////////////////////////////////////////////////////////////////
119	template <typename ...>
120	struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace;
121
122	#define BOOST_HANA_ADAPT_ADT(...) \
123	template <> \
124	struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace<>; \
125	BOOST_HANA_ADAPT_ADT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) \
126	static_assert(true, "force the usage of a trailing semicolon") \
127	/**/
128
129	#define BOOST_HANA_ADAPT_ADT_IMPL(N, ...) \
130	BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_ADT_IMPL_, N)(__VA_ARGS__)
131
132	<% (0..MAX_NUMBER_OF_MEMBERS).each do \|n\| %>
133	#define BOOST_HANA_ADAPT_ADT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { \|i\| ", m#{i}" }.join %>) \
134	namespace boost { namespace hana { \
135	template <> \
136	struct accessors_impl<TYPE> { \
137	template <typename ...> \
138	static constexpr auto apply() { \
139	struct member_names { \
140	static constexpr auto get() { \
141	return ::boost::hana::make_tuple( \
142	<%= (1..n).map { \|i\| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m#{i})" }.join(', ') %>\
143	); \
144	} \
145	}; \
146	return ::boost::hana::make_tuple( \
147	<%= (1..n).map { \|i\| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), BOOST_HANA_PP_DROP_FRONT m#{i})" }.join(', ') %>\
148	); \
149	} \
150	}; \
151	}} \
152	/**/
153	<% end %>
154
155	//////////////////////////////////////////////////////////////////////////////
156	// BOOST_HANA_DEFINE_STRUCT
157	//////////////////////////////////////////////////////////////////////////////
158	#define BOOST_HANA_DEFINE_STRUCT(...) \
159	BOOST_HANA_DEFINE_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)
160
161	#define BOOST_HANA_DEFINE_STRUCT_IMPL(N, ...) \
162	BOOST_HANA_PP_CONCAT(BOOST_HANA_DEFINE_STRUCT_IMPL_, N)(__VA_ARGS__)
163
164	<% (0..MAX_NUMBER_OF_MEMBERS).each do \|n\| %>
165	#define BOOST_HANA_DEFINE_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { \|i\| ", m#{i}" }.join %>) \
166	<%= (1..n).map { \|i\| "BOOST_HANA_PP_DROP_BACK m#{i} BOOST_HANA_PP_BACK m#{i};" }.join(' ') %> \
167	\
168	struct hana_accessors_impl { \
169	static constexpr auto apply() { \
170	struct member_names { \
171	static constexpr auto get() { \
172	return ::boost::hana::make_tuple( \
173	<%= (1..n).map { \|i\| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m#{i})" }.join(', ') %>\
174	); \
175	} \
176	}; \
177	return ::boost::hana::make_tuple( \
178	<%= (1..n).map { \|i\| "::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<#{i-1}, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m#{i}), &TYPE::BOOST_HANA_PP_BACK m#{i}>{})" }.join(', ') %>\
179	); \
180	} \
181	} \
182	/**/
183	<% end %>
184
185	#endif // !BOOST_HANA_DETAIL_STRUCT_MACROS_HPP