ceph/src/boost/boost/hana/detail/struct_macros.hpp.erb

   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.hpp.erb
   9
  10     'MAX_NUMBER_OF_MEMBERS' must be greater than 0. In case 'MAX_NUMBER_OF_MEMBERS'
  11     is not specified, it defaults to 40. To regenerate the default struct macros,
  12     issue the following command from the root of the project:
  13
  14       erb include/boost/hana/detail/struct_macros.hpp.erb > include/boost/hana/detail/struct_macros.hpp
  15
  16     [1]: http://en.wikipedia.org/wiki/ERuby
  17 %>
  18
  19 <%
  20     MAX_NUMBER_OF_MEMBERS = (ENV["MAX_NUMBER_OF_MEMBERS"] || 40).to_i
  21     raise "MAX_NUMBER_OF_MEMBERS must be > 0" if not MAX_NUMBER_OF_MEMBERS > 0
  22 %>
  23
  24 /*!
  25 @file
  26 Defines the `BOOST_HANA_DEFINE_STRUCT`, `BOOST_HANA_ADAPT_STRUCT`, and
  27 `BOOST_HANA_ADAPT_ADT` macros.
  28
  29 @copyright Louis Dionne 2013-2017
  30 Distributed under the Boost Software License, Version 1.0.
  31 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  32  */
  33
  34 //////////////////////////////////////////////////////////////////////////////
  35 // THIS FILE IS GENERATED FROM THE <boost/hana/detail/struct_macros.erb.hpp>
  36 // ERB TEMPLATE. DO NOT EDIT THIS FILE DIRECTLY.
  37 //
  38 // THE ERB TEMPLATE CONTAINS INFORMATION ABOUT HOW TO REGENERATE THIS FILE.
  39 //////////////////////////////////////////////////////////////////////////////
  40
  41 #ifndef BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
  42 #define BOOST_HANA_DETAIL_STRUCT_MACROS_HPP
  43
  44 #include <boost/hana/config.hpp>
  45 #include <boost/hana/detail/preprocessor.hpp>
  46 #include <boost/hana/pair.hpp>
  47 #include <boost/hana/string.hpp>
  48 #include <boost/hana/tuple.hpp>
  49
  50 #include <cstddef>
  51 #include <utility>
  52
  53
  54 BOOST_HANA_NAMESPACE_BEGIN namespace struct_detail {
  55     template <typename Memptr, Memptr ptr>
  56     struct member_ptr {
  57         template <typename T>
  58         constexpr decltype(auto) operator()(T&& t) const
  59         { return static_cast<T&&>(t).*ptr; }
  60     };
  61
  62     constexpr std::size_t strlen(char const* s) {
  63         std::size_t n = 0;
  64         while (*s++ != '\0')
  65             ++n;
  66         return n;
  67     }
  68
  69     template <std::size_t n, typename Names, std::size_t ...i>
  70     constexpr auto prepare_member_name_impl(std::index_sequence<i...>) {
  71         return hana::string_c<hana::at_c<n>(Names::get())[i]...>;
  72     }
  73
  74     template <std::size_t n, typename Names>
  75     constexpr auto prepare_member_name() {
  76         constexpr std::size_t len = strlen(hana::at_c<n>(Names::get()));
  77         return prepare_member_name_impl<n, Names>(std::make_index_sequence<len>{});
  78     }
  79 } BOOST_HANA_NAMESPACE_END
  80
  81 //////////////////////////////////////////////////////////////////////////////
  82 // BOOST_HANA_PP_NARG
  83 //////////////////////////////////////////////////////////////////////////////
  84 //! @ingroup group-details
  85 //! Macro expanding to the number of arguments it is passed.
  86 //!
  87 //! Specifically, `BOOST_HANA_PP_NARG(x1, ..., xn)` expands to `n`. It is
  88 //! an error to call this macro with 0 arguments.
  89 #define BOOST_HANA_PP_NARG(...) \
  90     BOOST_HANA_PP_NARG_IMPL(__VA_ARGS__, <%= (1..MAX_NUMBER_OF_MEMBERS).to_a.reverse.join(',') %>,)
  91
  92 #define BOOST_HANA_PP_NARG_IMPL(<%= (1..MAX_NUMBER_OF_MEMBERS).to_a.map { |i| "e#{i}" }.join(',') %>, N, ...) N
  93
  94 //////////////////////////////////////////////////////////////////////////////
  95 // BOOST_HANA_PP_BACK
  96 //////////////////////////////////////////////////////////////////////////////
  97 //! @ingroup group-details
  98 //! Expands to its last argument.
  99 #define BOOST_HANA_PP_BACK(...) \
 100     BOOST_HANA_PP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)
 101
 102 #define BOOST_HANA_PP_BACK_IMPL(N, ...) \
 103     BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_BACK_IMPL_, N)(__VA_ARGS__)
 104
 105 <% (1..MAX_NUMBER_OF_MEMBERS).each do |n| %>
 106 #define BOOST_HANA_PP_BACK_IMPL_<%= n %>(<%= (1..n).to_a.map { |i| "e#{i}" }.join(', ') %>) e<%= n %>
 107 <% end %>
 108
 109 //////////////////////////////////////////////////////////////////////////////
 110 // BOOST_HANA_PP_DROP_BACK
 111 //////////////////////////////////////////////////////////////////////////////
 112 //! @ingroup group-details
 113 //! Expands to all of its arguments, except for the last one.
 114 #define BOOST_HANA_PP_DROP_BACK(...) \
 115     BOOST_HANA_PP_DROP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)
 116
 117 #define BOOST_HANA_PP_DROP_BACK_IMPL(N, ...) \
 118     BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_DROP_BACK_IMPL_, N)(__VA_ARGS__)
 119
 120 <% (1..MAX_NUMBER_OF_MEMBERS).each do |n| %>
 121 #define BOOST_HANA_PP_DROP_BACK_IMPL_<%= n %>(<%= (1..n).to_a.map { |i| "e#{i}" }.join(', ') %>)<%= (1..n-1).to_a.map { |i| "e#{i}" }.join(', ') %>
 122 <% end %>
 123
 124 //////////////////////////////////////////////////////////////////////////////
 125 // BOOST_HANA_ADAPT_STRUCT
 126 //////////////////////////////////////////////////////////////////////////////
 127 template <typename ...>
 128 struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace;
 129
 130 #define BOOST_HANA_ADAPT_STRUCT(...)                                        \
 131   template <>                                                               \
 132   struct BOOST_HANA_ADAPT_STRUCT_must_be_called_in_the_global_namespace<>;  \
 133   BOOST_HANA_ADAPT_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)\
 134   static_assert(true, "force the usage of a trailing semicolon")            \
 135 /**/
 136
 137 #define BOOST_HANA_ADAPT_STRUCT_IMPL(N, ...) \
 138   BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_STRUCT_IMPL_, N)(__VA_ARGS__)
 139
 140 <% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
 141 #define BOOST_HANA_ADAPT_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)    \
 142     namespace boost { namespace hana {                                                            \
 143         template <>                                                                               \
 144         struct accessors_impl<TYPE> {                                                             \
 145             static constexpr auto apply() {                                                       \
 146                 struct member_names {                                                             \
 147                   static constexpr auto get() {                                                   \
 148                       return ::boost::hana::make_tuple(                                           \
 149                           <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(m#{i})" }.join(', ') %>   \
 150                       );                                                                          \
 151                   }                                                                               \
 152                 };                                                                                \
 153                 return ::boost::hana::make_tuple(                                                 \
 154                     <%= (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(', ') %>\
 155                 );                                                                                \
 156             }                                                                                     \
 157         };                                                                                        \
 158     }}                                                                                            \
 159 /**/
 160 <% end %>
 161
 162 //////////////////////////////////////////////////////////////////////////////
 163 // BOOST_HANA_ADAPT_ADT
 164 //////////////////////////////////////////////////////////////////////////////
 165 template <typename ...>
 166 struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace;
 167
 168 #define BOOST_HANA_ADAPT_ADT(...)                                           \
 169   template <>                                                               \
 170   struct BOOST_HANA_ADAPT_ADT_must_be_called_in_the_global_namespace<>;     \
 171   BOOST_HANA_ADAPT_ADT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)   \
 172   static_assert(true, "force the usage of a trailing semicolon")            \
 173 /**/
 174
 175 #define BOOST_HANA_ADAPT_ADT_IMPL(N, ...) \
 176   BOOST_HANA_PP_CONCAT(BOOST_HANA_ADAPT_ADT_IMPL_, N)(__VA_ARGS__)
 177
 178 <% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
 179 #define BOOST_HANA_ADAPT_ADT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)             \
 180     namespace boost { namespace hana {                                                                  \
 181         template <>                                                                                     \
 182         struct accessors_impl<TYPE> {                                                                   \
 183             template <typename ...>                                                                     \
 184             static constexpr auto apply() {                                                             \
 185                 struct member_names {                                                                   \
 186                   static constexpr auto get() {                                                         \
 187                       return ::boost::hana::make_tuple(                                                 \
 188                         <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m#{i})" }.join(', ') %>\
 189                       );                                                                                \
 190                   }                                                                                     \
 191                 };                                                                                      \
 192                 return ::boost::hana::make_tuple(                                                       \
 193                     <%= (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(', ') %>\
 194                 );                                                                                      \
 195             }                                                                                           \
 196         };                                                                                              \
 197     }}                                                                                                  \
 198 /**/
 199 <% end %>
 200
 201 //////////////////////////////////////////////////////////////////////////////
 202 // BOOST_HANA_DEFINE_STRUCT
 203 //////////////////////////////////////////////////////////////////////////////
 204 #define BOOST_HANA_DEFINE_STRUCT(...) \
 205     BOOST_HANA_DEFINE_STRUCT_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__)
 206
 207 #define BOOST_HANA_DEFINE_STRUCT_IMPL(N, ...) \
 208     BOOST_HANA_PP_CONCAT(BOOST_HANA_DEFINE_STRUCT_IMPL_, N)(__VA_ARGS__)
 209
 210 <% (0..MAX_NUMBER_OF_MEMBERS).each do |n| %>
 211 #define BOOST_HANA_DEFINE_STRUCT_IMPL_<%= n+1 %>(TYPE <%= (1..n).map { |i| ", m#{i}" }.join %>)       \
 212   <%= (1..n).map { |i| "BOOST_HANA_PP_DROP_BACK m#{i} BOOST_HANA_PP_BACK m#{i};" }.join(' ') %>       \
 213                                                                                                       \
 214   struct hana_accessors_impl {                                                                        \
 215     static constexpr auto apply() {                                                                   \
 216       struct member_names {                                                                           \
 217         static constexpr auto get() {                                                                 \
 218             return ::boost::hana::make_tuple(                                                         \
 219               <%= (1..n).map { |i| "BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m#{i})" }.join(', ') %>\
 220             );                                                                                        \
 221         }                                                                                             \
 222       };                                                                                              \
 223       return ::boost::hana::make_tuple(                                                               \
 224         <%= (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(', ') %>\
 225       );                                                                                              \
 226     }                                                                                                 \
 227   }                                                                                                   \
 228 /**/
 229 <% end %>
 230
 231 #endif // !BOOST_HANA_DETAIL_STRUCT_MACROS_HPP