diff options
| author | galaxycrab <UgnineSirdis@ydb.tech> | 2022-08-10 15:41:57 +0300 |
|---|---|---|
| committer | galaxycrab <UgnineSirdis@ydb.tech> | 2022-08-10 15:41:57 +0300 |
| commit | d305bd814a40254aef0919b960bc9f24a7e9569f (patch) | |
| tree | 5e7faba10a56448e5e76a9b406e01631ae7440bb /contrib | |
| parent | 811b039dffc7d5e35d3b8a34fad80b16c38f570c (diff) | |
| download | ydb-d305bd814a40254aef0919b960bc9f24a7e9569f.tar.gz | |
Rate limiting runtime in YQ
Diffstat (limited to 'contrib')
453 files changed, 287 insertions, 42604 deletions
diff --git a/contrib/restricted/boost/boost/hana.hpp b/contrib/restricted/boost/boost/hana.hpp deleted file mode 100644 index a8ad0413f1..0000000000 --- a/contrib/restricted/boost/boost/hana.hpp +++ /dev/null @@ -1,209 +0,0 @@ -/*! -@file -Includes all the library components except the adapters for external -libraries. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_HPP -#define BOOST_HANA_HPP - -//! @defgroup group-concepts Concepts -//! Concepts provided by the library. - -//! @defgroup group-datatypes Data types -//! General purpose data types provided by the library. - -//! @defgroup group-functional Functional -//! General purpose function objects. - -//! @defgroup group-core Core -//! Core utilities of the library. - -//! @defgroup group-experimental Experimental features -//! Experimental features that may or may not make it into the library. -//! These features should not expected to be stable. - -//! @defgroup group-ext External adapters -//! Adapters for external libraries. - -//! @defgroup group-config Configuration options -//! Configurable options to tweak the global behavior of the library. - -//! @defgroup group-assertions Assertions -//! Macros to perform different kinds of assertions. - -//! @defgroup group-details Details -//! Implementation details. Do not rely on anything here, even if it is -//! documented. - -// Include config.hpp first, so that warning messages about compiler support -// appear as soon as possible. -#include <boost/hana/config.hpp> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { - //! Namespace containing everything in the library. - namespace hana { - //! Namespace containing C++14 user-defined literals provided by Hana. - namespace literals {} - } -} -#endif - -#include <boost/hana/accessors.hpp> -#include <boost/hana/adapt_adt.hpp> -#include <boost/hana/adapt_struct.hpp> -#include <boost/hana/adjust.hpp> -#include <boost/hana/adjust_if.hpp> -#include <boost/hana/all.hpp> -#include <boost/hana/all_of.hpp> -#include <boost/hana/and.hpp> -#include <boost/hana/any.hpp> -#include <boost/hana/any_of.hpp> -#include <boost/hana/ap.hpp> -#include <boost/hana/append.hpp> -#include <boost/hana/assert.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/at_key.hpp> -#include <boost/hana/back.hpp> -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/cartesian_product.hpp> -#include <boost/hana/chain.hpp> -#include <boost/hana/comparing.hpp> -#include <boost/hana/concat.hpp> -#include <boost/hana/concept.hpp> -#include <boost/hana/contains.hpp> -#include <boost/hana/core.hpp> -#include <boost/hana/count.hpp> -#include <boost/hana/count_if.hpp> -#include <boost/hana/cycle.hpp> -#include <boost/hana/define_struct.hpp> -#include <boost/hana/difference.hpp> -#include <boost/hana/div.hpp> -#include <boost/hana/drop_back.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/drop_front_exactly.hpp> -#include <boost/hana/drop_while.hpp> -#include <boost/hana/duplicate.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/erase_key.hpp> -#include <boost/hana/eval.hpp> -#include <boost/hana/eval_if.hpp> -#include <boost/hana/extend.hpp> -#include <boost/hana/extract.hpp> -#include <boost/hana/fill.hpp> -#include <boost/hana/filter.hpp> -#include <boost/hana/find.hpp> -#include <boost/hana/find_if.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/flatten.hpp> -#include <boost/hana/fold.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/fold_right.hpp> -#include <boost/hana/for_each.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/functional.hpp> -#include <boost/hana/fuse.hpp> -#include <boost/hana/greater.hpp> -#include <boost/hana/greater_equal.hpp> -#include <boost/hana/group.hpp> -#include <boost/hana/index_if.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/insert.hpp> -#include <boost/hana/insert_range.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/intersection.hpp> -#include <boost/hana/intersperse.hpp> -#include <boost/hana/is_disjoint.hpp> -#include <boost/hana/is_empty.hpp> -#include <boost/hana/is_subset.hpp> -#include <boost/hana/keys.hpp> -#include <boost/hana/lazy.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/less.hpp> -#include <boost/hana/less_equal.hpp> -#include <boost/hana/lexicographical_compare.hpp> -#include <boost/hana/lift.hpp> -#include <boost/hana/map.hpp> -#include <boost/hana/max.hpp> -#include <boost/hana/maximum.hpp> -#include <boost/hana/members.hpp> -#include <boost/hana/min.hpp> -#include <boost/hana/minimum.hpp> -#include <boost/hana/minus.hpp> -#include <boost/hana/mod.hpp> -#include <boost/hana/monadic_compose.hpp> -#include <boost/hana/monadic_fold_left.hpp> -#include <boost/hana/monadic_fold_right.hpp> -#include <boost/hana/mult.hpp> -#include <boost/hana/negate.hpp> -#include <boost/hana/none.hpp> -#include <boost/hana/none_of.hpp> -#include <boost/hana/not.hpp> -#include <boost/hana/not_equal.hpp> -#include <boost/hana/one.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/or.hpp> -#include <boost/hana/ordering.hpp> -#include <boost/hana/pair.hpp> -#include <boost/hana/partition.hpp> -#include <boost/hana/permutations.hpp> -#include <boost/hana/plus.hpp> -#include <boost/hana/power.hpp> -#include <boost/hana/prefix.hpp> -#include <boost/hana/prepend.hpp> -#include <boost/hana/product.hpp> -#include <boost/hana/range.hpp> -#include <boost/hana/remove.hpp> -#include <boost/hana/remove_at.hpp> -#include <boost/hana/remove_if.hpp> -#include <boost/hana/remove_range.hpp> -#include <boost/hana/repeat.hpp> -#include <boost/hana/replace.hpp> -#include <boost/hana/replace_if.hpp> -#include <boost/hana/replicate.hpp> -#include <boost/hana/reverse.hpp> -#include <boost/hana/reverse_fold.hpp> -#include <boost/hana/scan_left.hpp> -#include <boost/hana/scan_right.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/set.hpp> -#include <boost/hana/size.hpp> -#include <boost/hana/slice.hpp> -#include <boost/hana/sort.hpp> -#include <boost/hana/span.hpp> -#include <boost/hana/string.hpp> -#include <boost/hana/suffix.hpp> -#include <boost/hana/sum.hpp> -#include <boost/hana/symmetric_difference.hpp> -#include <boost/hana/take_back.hpp> -#include <boost/hana/take_front.hpp> -#include <boost/hana/take_while.hpp> -#include <boost/hana/tap.hpp> -#include <boost/hana/then.hpp> -#include <boost/hana/traits.hpp> -#include <boost/hana/transform.hpp> -#include <boost/hana/tuple.hpp> -#include <boost/hana/type.hpp> -#include <boost/hana/unfold_left.hpp> -#include <boost/hana/unfold_right.hpp> -#include <boost/hana/union.hpp> -#include <boost/hana/unique.hpp> -#include <boost/hana/unpack.hpp> -#include <boost/hana/value.hpp> -#include <boost/hana/version.hpp> -#include <boost/hana/while.hpp> -#include <boost/hana/zero.hpp> -#include <boost/hana/zip.hpp> -#include <boost/hana/zip_shortest.hpp> -#include <boost/hana/zip_shortest_with.hpp> -#include <boost/hana/zip_with.hpp> - -#endif // !BOOST_HANA_HPP diff --git a/contrib/restricted/boost/boost/hana/accessors.hpp b/contrib/restricted/boost/boost/hana/accessors.hpp deleted file mode 100644 index 28204b6e31..0000000000 --- a/contrib/restricted/boost/boost/hana/accessors.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Defines `boost::hana::accessors`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ACCESSORS_HPP -#define BOOST_HANA_ACCESSORS_HPP - -#include <boost/hana/fwd/accessors.hpp> - -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename S> - struct accessors_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Struct<S>::value, - "hana::accessors<S> requires 'S' to be a Struct"); - #endif - - constexpr decltype(auto) operator()() const { - using Accessors = BOOST_HANA_DISPATCH_IF(accessors_impl<S>, - hana::Struct<S>::value - ); - - return Accessors::apply(); - } - }; - - template <typename S, bool condition> - struct accessors_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - namespace struct_detail { - template <typename ...> - struct is_valid { static constexpr bool value = true; }; - } - - template <typename S> - struct accessors_impl<S, when< - struct_detail::is_valid<typename S::hana_accessors_impl>::value - >> - : S::hana_accessors_impl - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ACCESSORS_HPP diff --git a/contrib/restricted/boost/boost/hana/adapt_adt.hpp b/contrib/restricted/boost/boost/hana/adapt_adt.hpp deleted file mode 100644 index 0bf73467ac..0000000000 --- a/contrib/restricted/boost/boost/hana/adapt_adt.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/*! -@file -Defines the `BOOST_HANA_ADAPT_ADT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ADAPT_ADT_HPP -#define BOOST_HANA_ADAPT_ADT_HPP - -#include <boost/hana/fwd/adapt_adt.hpp> - -#include <boost/hana/detail/struct_macros.hpp> - -#endif // !BOOST_HANA_ADAPT_ADT_HPP diff --git a/contrib/restricted/boost/boost/hana/adapt_struct.hpp b/contrib/restricted/boost/boost/hana/adapt_struct.hpp deleted file mode 100644 index c156f44d40..0000000000 --- a/contrib/restricted/boost/boost/hana/adapt_struct.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/*! -@file -Defines the `BOOST_HANA_ADAPT_STRUCT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ADAPT_STRUCT_HPP -#define BOOST_HANA_ADAPT_STRUCT_HPP - -#include <boost/hana/fwd/adapt_struct.hpp> - -#include <boost/hana/detail/struct_macros.hpp> - -#endif // !BOOST_HANA_ADAPT_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/adjust.hpp b/contrib/restricted/boost/boost/hana/adjust.hpp deleted file mode 100644 index e8bab2cac3..0000000000 --- a/contrib/restricted/boost/boost/hana/adjust.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Defines `boost::hana::adjust`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ADJUST_HPP -#define BOOST_HANA_ADJUST_HPP - -#include <boost/hana/fwd/adjust.hpp> - -#include <boost/hana/adjust_if.hpp> -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/equal.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Value, typename F> - constexpr auto adjust_t::operator()(Xs&& xs, Value&& value, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using Adjust = BOOST_HANA_DISPATCH_IF(adjust_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::adjust(xs, value, f) requires 'xs' to be a Functor"); - #endif - - return Adjust::apply(static_cast<Xs&&>(xs), - static_cast<Value&&>(value), - static_cast<F&&>(f)); - } - //! @endcond - - template <typename Fun, bool condition> - struct adjust_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename Value, typename F> - static constexpr auto apply(Xs&& xs, Value&& value, F&& f) { - return hana::adjust_if( - static_cast<Xs&&>(xs), - hana::equal.to(static_cast<Value&&>(value)), - static_cast<F&&>(f) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ADJUST_HPP diff --git a/contrib/restricted/boost/boost/hana/adjust_if.hpp b/contrib/restricted/boost/boost/hana/adjust_if.hpp deleted file mode 100644 index 8669009a9a..0000000000 --- a/contrib/restricted/boost/boost/hana/adjust_if.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Defines `boost::hana::adjust_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ADJUST_IF_HPP -#define BOOST_HANA_ADJUST_IF_HPP - -#include <boost/hana/fwd/adjust_if.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred, typename F> - constexpr auto adjust_if_t::operator()(Xs&& xs, Pred const& pred, F const& f) const { - using S = typename hana::tag_of<Xs>::type; - using AdjustIf = BOOST_HANA_DISPATCH_IF(adjust_if_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::adjust_if(xs, pred, f) requires 'xs' to be a Functor"); - #endif - - return AdjustIf::apply(static_cast<Xs&&>(xs), pred, f); - } - //! @endcond - - namespace detail { - template <typename Pred, typename F> - struct apply_if { - Pred const& pred; - F const& f; - - template <typename X> - constexpr decltype(auto) helper(bool cond, X&& x) const - { return cond ? f(static_cast<X&&>(x)) : static_cast<X&&>(x); } - - template <typename X> - constexpr decltype(auto) helper(hana::true_, X&& x) const - { return f(static_cast<X&&>(x)); } - - template <typename X> - constexpr decltype(auto) helper(hana::false_, X&& x) const - { return static_cast<X&&>(x); } - - - template <typename X> - constexpr decltype(auto) operator()(X&& x) const { - auto cond = hana::if_(pred(x), hana::true_c, hana::false_c); - return this->helper(cond, static_cast<X&&>(x)); - } - }; - } - - template <typename Fun, bool condition> - struct adjust_if_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename Pred, typename F> - static constexpr auto apply(Xs&& xs, Pred const& pred, F const& f) { - return hana::transform(static_cast<Xs&&>(xs), - detail::apply_if<Pred, F>{pred, f}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ADJUST_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/all.hpp b/contrib/restricted/boost/boost/hana/all.hpp deleted file mode 100644 index bc952c986f..0000000000 --- a/contrib/restricted/boost/boost/hana/all.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::all`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ALL_HPP -#define BOOST_HANA_ALL_HPP - -#include <boost/hana/fwd/all.hpp> - -#include <boost/hana/all_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/id.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto all_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using All = BOOST_HANA_DISPATCH_IF(all_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::all(xs) requires 'xs' to be a Searchable"); - #endif - - return All::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename S, bool condition> - struct all_impl<S, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return hana::all_of(static_cast<Xs&&>(xs), hana::id); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ALL_HPP diff --git a/contrib/restricted/boost/boost/hana/all_of.hpp b/contrib/restricted/boost/boost/hana/all_of.hpp deleted file mode 100644 index 5aff4a01e7..0000000000 --- a/contrib/restricted/boost/boost/hana/all_of.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines `boost::hana::all_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ALL_OF_HPP -#define BOOST_HANA_ALL_OF_HPP - -#include <boost/hana/fwd/all_of.hpp> - -#include <boost/hana/any_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto all_of_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using AllOf = BOOST_HANA_DISPATCH_IF(all_of_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::all_of(xs, pred) requires 'xs' to be a Searchable"); - #endif - - return AllOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct all_of_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::not_(hana::any_of(static_cast<Xs&&>(xs), - hana::compose(hana::not_, static_cast<Pred&&>(pred)))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ALL_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/and.hpp b/contrib/restricted/boost/boost/hana/and.hpp deleted file mode 100644 index df460d32a6..0000000000 --- a/contrib/restricted/boost/boost/hana/and.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::and_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_AND_HPP -#define BOOST_HANA_AND_HPP - -#include <boost/hana/fwd/and.hpp> - -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/variadic/foldl1.hpp> -#include <boost/hana/if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) and_t::operator()(X&& x, Y&& y) const { - using Bool = typename hana::tag_of<X>::type; - using And = BOOST_HANA_DISPATCH_IF(and_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::and_(x, y) requires 'x' to be a Logical"); - #endif - - return And::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - - template <typename X, typename ...Y> - constexpr decltype(auto) and_t::operator()(X&& x, Y&& ...y) const { - return detail::variadic::foldl1( - *this, - static_cast<X&&>(x), - static_cast<Y&&>(y)... - ); - } - //! @endcond - - template <typename L, bool condition> - struct and_impl<L, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::if_(x, static_cast<Y&&>(y), x); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_AND_HPP diff --git a/contrib/restricted/boost/boost/hana/any.hpp b/contrib/restricted/boost/boost/hana/any.hpp deleted file mode 100644 index 9141a758df..0000000000 --- a/contrib/restricted/boost/boost/hana/any.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::any`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ANY_HPP -#define BOOST_HANA_ANY_HPP - -#include <boost/hana/fwd/any.hpp> - -#include <boost/hana/any_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/id.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto any_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Any = BOOST_HANA_DISPATCH_IF(any_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::any(xs) requires 'xs' to be a Searchable"); - #endif - - return Any::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename S, bool condition> - struct any_impl<S, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return hana::any_of(static_cast<Xs&&>(xs), hana::id); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ANY_HPP diff --git a/contrib/restricted/boost/boost/hana/any_of.hpp b/contrib/restricted/boost/boost/hana/any_of.hpp deleted file mode 100644 index 59c130e54d..0000000000 --- a/contrib/restricted/boost/boost/hana/any_of.hpp +++ /dev/null @@ -1,192 +0,0 @@ -/*! -@file -Defines `boost::hana::any_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ANY_OF_HPP -#define BOOST_HANA_ANY_OF_HPP - -#include <boost/hana/fwd/any_of.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/is_empty.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto any_of_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using AnyOf = BOOST_HANA_DISPATCH_IF(any_of_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::any_of(xs, pred) requires 'xs' to be a Searchable"); - #endif - - return AnyOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct any_of_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S> - struct any_of_impl<S, when<Sequence<S>::value>> { - //! @cond - template <std::size_t k, std::size_t Len> - struct any_of_helper { - template <typename Xs, typename Pred> - static constexpr auto apply(bool prev_cond, Xs&& xs, Pred&& pred) { - return prev_cond ? hana::true_c - : any_of_impl::any_of_helper<k + 1, Len>::apply( - hana::if_(pred(hana::at_c<k>(xs)), hana::true_c, hana::false_c), - static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred) - ); - } - - template <typename Xs, typename Pred> - static constexpr auto apply(hana::true_, Xs&&, Pred&&) - { return hana::true_c; } - - template <typename Xs, typename Pred> - static constexpr auto apply(hana::false_, Xs&& xs, Pred&& pred) { - auto cond = hana::if_(pred(hana::at_c<k>(xs)), hana::true_c, - hana::false_c); - return any_of_impl::any_of_helper<k + 1, Len>::apply(cond, - static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - }; - - template <std::size_t Len> - struct any_of_helper<Len, Len> { - template <typename Cond, typename Xs, typename Pred> - static constexpr auto apply(Cond cond, Xs&&, Pred&&) - { return cond; } - }; - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - constexpr std::size_t len = decltype(hana::length(xs))::value; - return any_of_impl::any_of_helper<0, len>::apply(hana::false_c, - static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - //! @endcond - }; - - template <typename It> - struct any_of_impl<It, when< - hana::Iterable<It>::value && - !Sequence<It>::value - >> { - template <typename Xs, typename Pred> - static constexpr auto lazy_any_of_helper(hana::false_, bool prev_cond, Xs&& xs, Pred&& pred) { - decltype(auto) tail = hana::drop_front(static_cast<Xs&&>(xs)); - constexpr bool done = decltype(hana::is_empty(tail))::value; - return prev_cond ? hana::true_c - : lazy_any_of_helper(hana::bool_<done>{}, - hana::if_(pred(hana::front(xs)), hana::true_{}, hana::false_{}), - static_cast<decltype(tail)&&>(tail), - static_cast<Pred&&>(pred) - ); - } - - template <typename Xs, typename Pred> - static constexpr auto lazy_any_of_helper(hana::false_, hana::true_, Xs&&, Pred&&) - { return hana::true_c; } - - template <typename Xs, typename Pred> - static constexpr auto lazy_any_of_helper(hana::false_, hana::false_, Xs&& xs, Pred&& pred) { - constexpr bool done = decltype(hana::is_empty(hana::drop_front(xs)))::value; - return lazy_any_of_helper(hana::bool_c<done>, - hana::if_(pred(hana::front(xs)), hana::true_c, hana::false_c), - hana::drop_front(static_cast<Xs&&>(xs)), - static_cast<Pred&&>(pred) - ); - } - - template <typename Cond, typename Xs, typename Pred> - static constexpr auto lazy_any_of_helper(hana::true_, Cond cond, Xs&&, Pred&&) - { return cond; } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - constexpr bool done = decltype(hana::is_empty(xs))::value; - return lazy_any_of_helper(hana::bool_c<done>, hana::false_c, - static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - }; - - template <typename T, std::size_t N> - struct any_of_impl<T[N]> { - template <typename Xs, typename Pred> - static constexpr bool any_of_helper(bool cond, Xs&& xs, Pred&& pred) { - if (cond) return true; - for (std::size_t i = 1; i < N; ++i) - if (pred(static_cast<Xs&&>(xs)[i])) - return true; - return false; - } - - // Since an array contains homogeneous data, if the predicate returns - // a compile-time logical at any index, it must do so at every index - // (because the type of the elements won't change)! In this case, we - // then only need to evaluate the predicate on the first element. - template <typename Xs, typename Pred> - static constexpr auto - any_of_helper(hana::true_, Xs&& /*xs*/, Pred&&) - { return hana::true_c; } - - template <typename Xs, typename Pred> - static constexpr auto - any_of_helper(hana::false_, Xs&&, Pred&&) - { return hana::false_c; } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - auto cond = hana::if_(pred(static_cast<Xs&&>(xs)[0]), hana::true_c, - hana::false_c); - return any_of_helper(cond, static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - }; - - template <typename S> - struct any_of_impl<S, when<hana::Struct<S>::value>> { - template <typename X, typename Pred> - static constexpr decltype(auto) apply(X const&, Pred&& pred) { - return hana::any_of(hana::accessors<S>(), - hana::compose(static_cast<Pred&&>(pred), hana::first)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ANY_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/ap.hpp b/contrib/restricted/boost/boost/hana/ap.hpp deleted file mode 100644 index a96f7d1aa7..0000000000 --- a/contrib/restricted/boost/boost/hana/ap.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Defines `boost::hana::ap`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_AP_HPP -#define BOOST_HANA_AP_HPP - -#include <boost/hana/fwd/ap.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/applicative.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/variadic/foldl1.hpp> -#include <boost/hana/functional/curry.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename A, bool condition> - struct ap_impl<A, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...args) = delete; - }; - - //! @cond - template <typename F, typename X> - constexpr decltype(auto) ap_t::operator()(F&& f, X&& x) const { - using Function = typename hana::tag_of<F>::type; - using Value = typename hana::tag_of<X>::type; - using Ap = BOOST_HANA_DISPATCH_IF(ap_impl<Function>, - hana::Applicative<Function>::value && hana::Applicative<Value>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Applicative<Function>::value, - "hana::ap(f, x) requires 'f' to be an Applicative"); - - static_assert(hana::Applicative<Value>::value, - "hana::ap(f, x) requires 'x' to be an Applicative"); - #endif - - return Ap::apply(static_cast<F&&>(f), static_cast<X&&>(x)); - } - - template <typename F, typename ...Xs> - constexpr decltype(auto) ap_t::operator()(F&& f, Xs&& ...xs) const { - static_assert(sizeof...(xs) >= 1, - "hana::ap must be called with at least two arguments"); - - return detail::variadic::foldl1( - *this, - hana::transform(static_cast<F&&>(f), hana::curry<sizeof...(xs)>), - static_cast<Xs&&>(xs)... - ); - } - //! @endcond - - template <typename S> - struct ap_impl<S, when<Sequence<S>::value>> { - template <typename F, typename X> - static constexpr decltype(auto) apply(F&& f, X&& x) { - return hana::chain( - static_cast<F&&>(f), - hana::partial(hana::transform, static_cast<X&&>(x)) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_AP_HPP diff --git a/contrib/restricted/boost/boost/hana/append.hpp b/contrib/restricted/boost/boost/hana/append.hpp deleted file mode 100644 index 951f24d35e..0000000000 --- a/contrib/restricted/boost/boost/hana/append.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Defines `boost::hana::append`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_APPEND_HPP -#define BOOST_HANA_APPEND_HPP - -#include <boost/hana/fwd/append.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concat.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/lift.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename X> - constexpr auto append_t::operator()(Xs&& xs, X&& x) const { - using M = typename hana::tag_of<Xs>::type; - using Append = BOOST_HANA_DISPATCH_IF(append_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::append(xs, x) requires 'xs' to be a MonadPlus"); - #endif - - return Append::apply(static_cast<Xs&&>(xs), static_cast<X&&>(x)); - } - //! @endcond - - template <typename M, bool condition> - struct append_impl<M, when<condition>> : default_ { - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - return hana::concat(static_cast<Xs&&>(xs), - hana::lift<M>(static_cast<X&&>(x))); - } - }; - - template <typename S> - struct append_impl<S, when<Sequence<S>::value>> { - template <typename Xs, typename X, std::size_t ...i> - static constexpr auto append_helper(Xs&& xs, X&& x, std::index_sequence<i...>) { - return hana::make<S>( - hana::at_c<i>(static_cast<Xs&&>(xs))..., static_cast<X&&>(x) - ); - } - - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - constexpr std::size_t N = decltype(hana::length(xs))::value; - return append_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), - std::make_index_sequence<N>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_APPEND_HPP diff --git a/contrib/restricted/boost/boost/hana/assert.hpp b/contrib/restricted/boost/boost/hana/assert.hpp deleted file mode 100644 index 9603107699..0000000000 --- a/contrib/restricted/boost/boost/hana/assert.hpp +++ /dev/null @@ -1,327 +0,0 @@ -/*! -@file -Defines macros to perform different kinds of assertions. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ASSERT_HPP -#define BOOST_HANA_ASSERT_HPP - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/preprocessor.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/value.hpp> - -#include <cstdio> -#include <cstdlib> - - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - //! @ingroup group-assertions - //! Expands to a runtime assertion. - //! - //! Given a condition known at runtime, this macro expands to a runtime - //! assertion similar to the `assert` macro. The provided condition must - //! be explicitly convertible to a `bool`, and it must not be a model of - //! the `Constant` concept. If the condition is a `Constant`, a static - //! assertion will be triggered, asking you to use the - //! `BOOST_HANA_CONSTANT_ASSERT` macro instead. - //! - //! @note - //! This macro may only be used at function scope. -# define BOOST_HANA_RUNTIME_ASSERT(condition) unspecified - - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_RUNTIME_ASSERT`, but allows providing a - //! custom failure message. - //! - //! @warning - //! Conditions that contain multiple comma-separated elements should be - //! parenthesized. -# define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) unspecified - - //! @ingroup group-assertions - //! Compile-time assertion for `Constant`s. - //! - //! Given a condition known at compile-time in the form of a `Constant`, - //! this macro expands to a compile-time assertion similar to a `static_assert`. - //! The provided condition must be a model of the `Constant` concept, in - //! which case its value is retrieved using `hana::value` and then converted - //! to a `bool`. If the condition is not a `Constant`, a static assertion - //! will be triggered, asking you to use the `BOOST_HANA_RUNTIME_ASSERT` - //! macro instead. - //! - //! This macro may be used at global/namespace scope and function scope - //! only; it may not be used at class scope. Note that the condition may - //! never be evaluated at runtime. Hence, any side effect may not take - //! place (but you shouldn't rely on side effects inside assertions anyway). -# define BOOST_HANA_CONSTANT_ASSERT(condition) unspecified - - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_CONSTANT_ASSERT`, but allows providing a - //! custom failure message. - //! - //! @warning - //! Conditions that contain multiple comma-separated elements should be - //! parenthesized. -# define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) unspecified - - //! @ingroup group-assertions - //! Expands to the strongest form of assertion possible for the given - //! condition. - //! - //! Given a condition, `BOOST_HANA_ASSERT` expands either to a compile-time - //! or to a runtime assertion, depending on whether the value of the - //! condition is known at compile-time or at runtime. Compile-time - //! assertions are always preferred over runtime assertions. If the - //! condition is a model of the `Constant` concept, its value (retrievable - //! with `hana::value`) is assumed to be explicitly convertible to `bool`, - //! and a compile-time assertion is performed on it. Otherwise, the - //! condition itself is assumed to be explicitly convertible to `bool`, - //! and a runtime assertion is performed on it. - //! - //! If the assertion can be carried out at compile-time, the condition - //! is not guaranteed to be evaluated at runtime at all (but it may). - //! Hence, in general, you shouldn't rely on side effects that take place - //! inside an assertion. - //! - //! @note - //! This macro may only be used at function scope. -# define BOOST_HANA_ASSERT(condition) unspecified - - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_ASSERT`, but allows providing a custom - //! failure message. - //! - //! @warning - //! Conditions that contain multiple comma-separated elements should be - //! parenthesized. -# define BOOST_HANA_ASSERT_MSG(condition, message) unspecified - - //! @ingroup group-assertions - //! Expands to a static assertion or a runtime assertion, depending on - //! whether `constexpr` lambdas are supported. - //! - //! This macro is used to assert on a condition that would be a constant - //! expression if constexpr lambdas were supported. Right now, constexpr - //! lambdas are not supported, and this is always a runtime assertion. - //! Specifically, this is equivalent to `BOOST_HANA_RUNTIME_ASSERT`. -# define BOOST_HANA_CONSTEXPR_ASSERT(condition) unspecified - - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT`, but allows providing a - //! custom failure message. -# define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) unspecified - -#elif defined(BOOST_HANA_CONFIG_DISABLE_ASSERTIONS) - -# define BOOST_HANA_CONSTANT_ASSERT(...) /* nothing */ -# define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) /* nothing */ - -# define BOOST_HANA_RUNTIME_ASSERT(...) /* nothing */ -# define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) /* nothing */ - -# define BOOST_HANA_ASSERT(...) /* nothing */ -# define BOOST_HANA_ASSERT_MSG(condition, message) /* nothing */ - -# define BOOST_HANA_CONSTEXPR_ASSERT(...) /* nothing */ -# define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) /* nothing */ - -#else - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_RUNTIME_ASSERT and BOOST_HANA_RUNTIME_ASSERT_MSG -////////////////////////////////////////////////////////////////////////////// -# define BOOST_HANA_RUNTIME_ASSERT_MSG(condition, message) \ - BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ -/**/ - -# define BOOST_HANA_RUNTIME_ASSERT(...) \ - BOOST_HANA_RUNTIME_CHECK(__VA_ARGS__) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_CONSTANT_ASSERT and BOOST_HANA_CONSTANT_ASSERT_MSG -////////////////////////////////////////////////////////////////////////////// -# define BOOST_HANA_CONSTANT_ASSERT_MSG(condition, message) \ - BOOST_HANA_CONSTANT_CHECK_MSG(condition, message) \ -/**/ - -# define BOOST_HANA_CONSTANT_ASSERT(...) \ - BOOST_HANA_CONSTANT_CHECK(__VA_ARGS__) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_ASSERT and BOOST_HANA_ASSERT_MSG -////////////////////////////////////////////////////////////////////////////// -# define BOOST_HANA_ASSERT_MSG(condition, message) \ - BOOST_HANA_CHECK_MSG(condition, message) \ -/**/ - -# define BOOST_HANA_ASSERT(...) \ - BOOST_HANA_CHECK(__VA_ARGS__) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_CONSTEXPR_ASSERT and BOOST_HANA_CONSTEXPR_ASSERT_MSG -////////////////////////////////////////////////////////////////////////////// -# define BOOST_HANA_CONSTEXPR_ASSERT_MSG(condition, message) \ - BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ -/**/ - -# define BOOST_HANA_CONSTEXPR_ASSERT(...) \ - BOOST_HANA_CONSTEXPR_CHECK(__VA_ARGS__) \ -/**/ - -#endif - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_RUNTIME_CHECK and BOOST_HANA_RUNTIME_CHECK_MSG -////////////////////////////////////////////////////////////////////////////// - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA_RUNTIME_ASSERT_MSG`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ - do { \ - auto __hana_tmp = condition; \ - static_assert(!::boost::hana::Constant<decltype(__hana_tmp)>::value,\ - "the expression (" # condition ") yields a Constant; " \ - "use BOOST_HANA_CONSTANT_ASSERT instead"); \ - \ - if (!static_cast<bool>(__hana_tmp)) { \ - ::std::fprintf(stderr, "Assertion failed: " \ - "(%s), function %s, file %s, line %i.\n", \ - message, __func__, __FILE__, __LINE__); \ - ::std::abort(); \ - } \ - } while (false); \ - static_assert(true, "force trailing semicolon") \ -/**/ - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA_RUNTIME_ASSERT`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_RUNTIME_CHECK(...) \ - BOOST_HANA_RUNTIME_CHECK_MSG( \ - (__VA_ARGS__), \ - BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ - ) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_CONSTANT_CHECK and BOOST_HANA_CONSTANT_CHECK_MSG -////////////////////////////////////////////////////////////////////////////// - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA_CONSTANT_ASSERT_MSG`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_CONSTANT_CHECK_MSG(condition, message) \ - auto BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__) = condition; \ - static_assert(::boost::hana::Constant< \ - decltype(BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__)) \ - >::value, \ - "the expression " # condition " does not yield a Constant; " \ - "use BOOST_HANA_RUNTIME_ASSERT instead"); \ - static_assert(::boost::hana::value< \ - decltype(BOOST_HANA_PP_CONCAT(__hana_tmp_, __LINE__)) \ - >(), message); \ - static_assert(true, "force trailing semicolon") \ -/**/ - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA_CONSTANT_ASSERT`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_CONSTANT_CHECK(...) \ - BOOST_HANA_CONSTANT_CHECK_MSG( \ - (__VA_ARGS__), \ - BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ - ) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_CHECK and BOOST_HANA_CHECK_MSG -////////////////////////////////////////////////////////////////////////////// - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA_ASSERT_MSG`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_CHECK_MSG(condition, message) \ - do { \ - auto __hana_tmp = condition; \ - ::boost::hana::if_(::boost::hana::bool_c< \ - ::boost::hana::Constant<decltype(__hana_tmp)>::value>, \ - [](auto expr) { \ - static_assert(::boost::hana::value<decltype(expr)>(), \ - message); \ - }, \ - [](auto expr) { \ - if (!static_cast<bool>(expr)) { \ - ::std::fprintf(stderr, "Assertion failed: " \ - "(%s), function %s, file %s, line %i.\n", \ - message, __func__, __FILE__, __LINE__); \ - ::std::abort(); \ - } \ - } \ - )(__hana_tmp); \ - } while (false); \ - static_assert(true, "force trailing semicolon") \ -/**/ - -//! @ingroup group-assertions -//! Equivalent to `BOOST_HANA__ASSERT`, but not influenced by the -//! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. For internal use only. -# define BOOST_HANA_CHECK(...) \ - BOOST_HANA_CHECK_MSG( \ - (__VA_ARGS__), \ - BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ - ) \ -/**/ - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_CONSTEXPR_CHECK and BOOST_HANA_CONSTEXPR_CHECK_MSG -////////////////////////////////////////////////////////////////////////////// - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT_MSG`, but not influenced by - //! the `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. - //! For internal use only. -# define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) implementation-defined - - //! @ingroup group-assertions - //! Equivalent to `BOOST_HANA_CONSTEXPR_ASSERT`, but not influenced by the - //! `BOOST_HANA_CONFIG_DISABLE_ASSERTIONS` config macro. - //! For internal use only. -# define BOOST_HANA_CONSTEXPR_CHECK(...) implementation-defined - -#elif defined(BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA) - -# define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ - static_assert(condition, message) \ -/**/ - -# define BOOST_HANA_CONSTEXPR_CHECK(...) \ - static_assert((__VA_ARGS__), BOOST_HANA_PP_STRINGIZE(__VA_ARGS__)) \ -/**/ - -#else - -# define BOOST_HANA_CONSTEXPR_CHECK_MSG(condition, message) \ - BOOST_HANA_RUNTIME_CHECK_MSG(condition, message) \ -/**/ - -# define BOOST_HANA_CONSTEXPR_CHECK(...) \ - BOOST_HANA_CONSTEXPR_CHECK_MSG( \ - (__VA_ARGS__), \ - BOOST_HANA_PP_STRINGIZE(__VA_ARGS__) \ - ) \ -/**/ - -#endif - -#endif // !BOOST_HANA_ASSERT_HPP diff --git a/contrib/restricted/boost/boost/hana/at.hpp b/contrib/restricted/boost/boost/hana/at.hpp deleted file mode 100644 index c3f158b0ff..0000000000 --- a/contrib/restricted/boost/boost/hana/at.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Defines `boost::hana::at` and `boost::hana::at_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_AT_HPP -#define BOOST_HANA_AT_HPP - -#include <boost/hana/fwd/at.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr decltype(auto) at_t::operator()(Xs&& xs, N const& n) const { - using It = typename hana::tag_of<Xs>::type; - using At = BOOST_HANA_DISPATCH_IF(at_impl<It>, - hana::Iterable<It>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::at(xs, n) requires 'xs' to be an Iterable"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::at(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - return At::apply(static_cast<Xs&&>(xs), n); - } - //! @endcond - - template <typename It, bool condition> - struct at_impl<It, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <std::size_t n, typename Xs> - constexpr decltype(auto) at_c(Xs&& xs) { - return hana::at(static_cast<Xs&&>(xs), hana::size_t<n>{}); - } -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/at_key.hpp b/contrib/restricted/boost/boost/hana/at_key.hpp deleted file mode 100644 index e4f2e11255..0000000000 --- a/contrib/restricted/boost/boost/hana/at_key.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*! -@file -Defines `boost::hana::at_key`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_AT_KEY_HPP -#define BOOST_HANA_AT_KEY_HPP - -#include <boost/hana/fwd/at_key.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/find.hpp> -#include <boost/hana/find_if.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/functional/on.hpp> -#include <boost/hana/index_if.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/second.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Key> - constexpr decltype(auto) at_key_t::operator()(Xs&& xs, Key const& key) const { - using S = typename hana::tag_of<Xs>::type; - using AtKey = BOOST_HANA_DISPATCH_IF(at_key_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::at_key(xs, key) requires 'xs' to be Searchable"); - #endif - - return AtKey::apply(static_cast<Xs&&>(xs), key); - } - //! @endcond - - template <typename S, bool condition> - struct at_key_impl<S, when<condition>> : default_ { - template <typename Xs, typename Key> - static constexpr auto apply(Xs&& xs, Key const& key) { - return hana::find(static_cast<Xs&&>(xs), key).value(); - } - }; - - namespace at_key_detail { - template <typename T> - struct equal_to { - T const& t; - template <typename U> - constexpr auto operator()(U const& u) const { - return hana::equal(t, u); - } - }; - } - - template <typename S> - struct at_key_impl<S, when<hana::Sequence<S>::value>> { - template <typename Xs, typename Key> - static constexpr decltype(auto) apply(Xs&& xs, Key const& key) { - using Result = decltype(hana::index_if( - static_cast<Xs&&>(xs), at_key_detail::equal_to<Key>{key})); - - return hana::at(static_cast<Xs&&>(xs), Result{}.value()); - } - }; - - template <typename S> - struct at_key_impl<S, when<hana::Struct<S>::value>> { - template <typename X, typename Key> - static constexpr decltype(auto) apply(X&& x, Key const& key) { - auto accessor = hana::second(*hana::find_if(hana::accessors<S>(), - hana::equal.to(key) ^hana::on^ hana::first - )); - return accessor(static_cast<X&&>(x)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_AT_KEY_HPP diff --git a/contrib/restricted/boost/boost/hana/back.hpp b/contrib/restricted/boost/boost/hana/back.hpp deleted file mode 100644 index 4fed83f032..0000000000 --- a/contrib/restricted/boost/boost/hana/back.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Defines `boost::hana::back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_BACK_HPP -#define BOOST_HANA_BACK_HPP - -#include <boost/hana/fwd/back.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr decltype(auto) back_t::operator()(Xs&& xs) const { - using It = typename hana::tag_of<Xs>::type; - using Back = BOOST_HANA_DISPATCH_IF(back_impl<It>, - hana::Iterable<It>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::back(xs) requires 'xs' to be an Iterable"); - #endif - - return Back::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename It, bool condition> - struct back_impl<It, when<condition>> : default_ { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - constexpr std::size_t len = decltype(hana::length(xs))::value; - static_assert(len > 0, "hana::back(xs) requires 'xs' to be non-empty"); - return hana::at_c<len - 1>(static_cast<Xs&&>(xs)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/basic_tuple.hpp b/contrib/restricted/boost/boost/hana/basic_tuple.hpp deleted file mode 100644 index 3e624694e0..0000000000 --- a/contrib/restricted/boost/boost/hana/basic_tuple.hpp +++ /dev/null @@ -1,256 +0,0 @@ -/*! -@file -Defines `boost::hana::basic_tuple`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_BASIC_TUPLE_HPP -#define BOOST_HANA_BASIC_TUPLE_HPP - -#include <boost/hana/fwd/basic_tuple.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/ebo.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/bool.hpp> -#include <boost/hana/fwd/concept/sequence.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/integral_constant.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/transform.hpp> -#include <boost/hana/fwd/unpack.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - ////////////////////////////////////////////////////////////////////// - // basic_tuple_impl<n, Xn> - ////////////////////////////////////////////////////////////////////// - template <std::size_t> struct bti; // basic_tuple_index - - struct from_other { }; - - template <typename Indices, typename ...Xn> - struct basic_tuple_impl; - - template <std::size_t ...n, typename ...Xn> - struct basic_tuple_impl<std::index_sequence<n...>, Xn...> - : detail::ebo<bti<n>, Xn>... - { - static constexpr std::size_t size_ = sizeof...(Xn); - - constexpr basic_tuple_impl() = default; - - template <typename Other> - explicit constexpr basic_tuple_impl(detail::from_other, Other&& other) - : detail::ebo<bti<n>, Xn>(detail::ebo_get<bti<n>>(static_cast<Other&&>(other)))... - { } - - template <typename ...Yn> - explicit constexpr basic_tuple_impl(Yn&& ...yn) - : detail::ebo<bti<n>, Xn>(static_cast<Yn&&>(yn))... - { } - }; - } - - ////////////////////////////////////////////////////////////////////////// - // basic_tuple - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename ...Xn> - struct basic_tuple final - : detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...> - { - using Base = detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...>; - - constexpr basic_tuple() = default; - - // copy constructor - template <typename Other, typename = typename std::enable_if< - std::is_same<typename detail::decay<Other>::type, basic_tuple>::value - >::type> - constexpr basic_tuple(Other&& other) - : Base(detail::from_other{}, static_cast<Other&&>(other)) - { } - - template <typename ...Yn> - explicit constexpr basic_tuple(Yn&& ...yn) - : Base(static_cast<Yn&&>(yn)...) - { } - }; - //! @endcond - - template <typename ...Xn> - struct tag_of<basic_tuple<Xn...>> { - using type = basic_tuple_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<basic_tuple_tag> { - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr decltype(auto) - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...> const& xs, F&& f) { - return static_cast<F&&>(f)( - detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn> const&>(xs) - )... - ); - } - - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr decltype(auto) - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>& xs, F&& f) { - return static_cast<F&&>(f)( - detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn>&>(xs) - )... - ); - } - - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr decltype(auto) - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>&& xs, F&& f) { - return static_cast<F&&>(f)( - detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn>&&>(xs) - )... - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Functor - ////////////////////////////////////////////////////////////////////////// - template <> - struct transform_impl<basic_tuple_tag> { - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr auto - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...> const& xs, F const& f) { - return hana::make_basic_tuple( - f(detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn> const&>(xs) - ))... - ); - } - - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr auto - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>& xs, F const& f) { - return hana::make_basic_tuple( - f(detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn>&>(xs) - ))... - ); - } - - template <std::size_t ...i, typename ...Xn, typename F> - static constexpr auto - apply(detail::basic_tuple_impl<std::index_sequence<i...>, Xn...>&& xs, F const& f) { - return hana::make_basic_tuple( - f(detail::ebo_get<detail::bti<i>>( - static_cast<detail::ebo<detail::bti<i>, Xn>&&>(xs) - ))... - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<basic_tuple_tag> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t index = N::value; - return detail::ebo_get<detail::bti<index>>(static_cast<Xs&&>(xs)); - } - }; - - template <> - struct drop_front_impl<basic_tuple_tag> { - template <std::size_t N, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make_basic_tuple( - detail::ebo_get<detail::bti<i+N>>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t len = detail::decay<Xs>::type::size_; - return drop_front_helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence< - N::value < len ? len - N::value : 0 - >{}); - } - }; - - template <> - struct is_empty_impl<basic_tuple_tag> { - template <typename ...Xs> - static constexpr hana::bool_<sizeof...(Xs) == 0> - apply(basic_tuple<Xs...> const&) - { return {}; } - }; - - // compile-time optimizations (to reduce the # of function instantiations) - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(basic_tuple<Xs...> const& xs) { - return detail::ebo_get<detail::bti<n>>(xs); - } - - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(basic_tuple<Xs...>& xs) { - return detail::ebo_get<detail::bti<n>>(xs); - } - - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(basic_tuple<Xs...>&& xs) { - return detail::ebo_get<detail::bti<n>>(static_cast<basic_tuple<Xs...>&&>(xs)); - } - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct Sequence<basic_tuple_tag> { - static constexpr bool value = true; - }; - - template <> - struct make_impl<basic_tuple_tag> { - template <typename ...Xn> - static constexpr basic_tuple<typename detail::decay<Xn>::type...> - apply(Xn&& ...xn) { - return basic_tuple<typename detail::decay<Xn>::type...>{ - static_cast<Xn&&>(xn)... - }; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // length - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<basic_tuple_tag> { - template <typename ...Xn> - static constexpr auto apply(basic_tuple<Xn...> const&) { - return hana::size_t<sizeof...(Xn)>{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_BASIC_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/bool.hpp b/contrib/restricted/boost/boost/hana/bool.hpp deleted file mode 100644 index 5774ccb78c..0000000000 --- a/contrib/restricted/boost/boost/hana/bool.hpp +++ /dev/null @@ -1,271 +0,0 @@ -/*! -@file -Defines the `Logical` and `Comparable` models of `boost::hana::integral_constant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_BOOL_HPP -#define BOOST_HANA_BOOL_HPP - -#include <boost/hana/fwd/bool.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/operators/arithmetic.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/logical.hpp> -#include <boost/hana/detail/operators/orderable.hpp> -#include <boost/hana/eval.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/eval_if.hpp> -#include <boost/hana/fwd/if.hpp> -#include <boost/hana/fwd/value.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // integral_constant - ////////////////////////////////////////////////////////////////////////// - //! @cond - namespace ic_detail { - template <typename T, T N, typename = std::make_integer_sequence<T, N>> - struct go; - - template <typename T, T N, T ...i> - struct go<T, N, std::integer_sequence<T, i...>> { - using swallow = T[]; - - template <typename F> - static constexpr void with_index(F&& f) - { (void)swallow{T{}, ((void)f(integral_constant<T, i>{}), i)...}; } - - template <typename F> - static constexpr void without_index(F&& f) - { (void)swallow{T{}, ((void)f(), i)...}; } - }; - - template <typename T, T v> - template <typename F> - constexpr void with_index_t<T, v>::operator()(F&& f) const - { go<T, ((void)sizeof(&f), v)>::with_index(static_cast<F&&>(f)); } - - template <typename T, T v> - template <typename F> - constexpr void times_t<T, v>::operator()(F&& f) const - { go<T, ((void)sizeof(&f), v)>::without_index(static_cast<F&&>(f)); } - - // avoid link-time error - template <typename T, T v> - constexpr with_index_t<T, v> times_t<T, v>::with_index; - } - - // avoid link-time error - template <typename T, T v> - constexpr ic_detail::times_t<T, v> integral_constant<T, v>::times; - - template <typename T, T v> - struct tag_of<integral_constant<T, v>> { - using type = integral_constant_tag<T>; - }; - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename T> - struct comparable_operators<integral_constant_tag<T>> { - static constexpr bool value = true; - }; - template <typename T> - struct orderable_operators<integral_constant_tag<T>> { - static constexpr bool value = true; - }; - template <typename T> - struct arithmetic_operators<integral_constant_tag<T>> { - static constexpr bool value = true; - }; - template <typename T> - struct logical_operators<integral_constant_tag<T>> { - static constexpr bool value = true; - }; - } - -#define BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(op) \ - template <typename U, U u, typename V, V v> \ - constexpr integral_constant<decltype(u op v), (u op v)> \ - operator op(integral_constant<U, u>, integral_constant<V, v>) \ - { return {}; } \ - /**/ - -#define BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(op) \ - template <typename U, U u> \ - constexpr integral_constant<decltype(op u), (op u)> \ - operator op(integral_constant<U, u>) \ - { return {}; } \ - /**/ - - // Arithmetic - BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(+) - - // Bitwise - BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(~) - BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(&) - BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(|) - BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(^) - BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(<<) - BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(>>) - -#undef BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP -#undef BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP - - - ////////////////////////////////////////////////////////////////////////// - // User-defined literal - ////////////////////////////////////////////////////////////////////////// - namespace ic_detail { - - constexpr int to_int(char c) { - int result = 0; - - if (c >= 'A' && c <= 'F') { - result = static_cast<int>(c) - static_cast<int>('A') + 10; - } - else if (c >= 'a' && c <= 'f') { - result = static_cast<int>(c) - static_cast<int>('a') + 10; - } - else { - result = static_cast<int>(c) - static_cast<int>('0'); - } - - return result; - } - - template<std::size_t N> - constexpr long long parse(const char (&arr)[N]) { - long long base = 10; - std::size_t offset = 0; - - if (N > 2) { - bool starts_with_zero = arr[0] == '0'; - bool is_hex = starts_with_zero && arr[1] == 'x'; - bool is_binary = starts_with_zero && arr[1] == 'b'; - - if (is_hex) { - //0xDEADBEEF (hexadecimal) - base = 16; - offset = 2; - } - else if (is_binary) { - //0b101011101 (binary) - base = 2; - offset = 2; - } - else if (starts_with_zero) { - //012345 (octal) - base = 8; - offset = 1; - } - } - - long long number = 0; - long long multiplier = 1; - - for (std::size_t i = 0; i < N - offset; ++i) { - char c = arr[N - 1 - i]; - if (c != '\'') { // skip digit separators - number += to_int(c) * multiplier; - multiplier *= base; - } - } - - return number; - } - } - - namespace literals { - template <char ...c> - constexpr auto operator"" _c() { - return hana::llong<ic_detail::parse<sizeof...(c)>({c...})>{}; - } - } - - ////////////////////////////////////////////////////////////////////////// - // Model of Constant/IntegralConstant - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct IntegralConstant<integral_constant_tag<T>> { - static constexpr bool value = true; - }; - - template <typename T, typename C> - struct to_impl<integral_constant_tag<T>, C, when<hana::IntegralConstant<C>::value>> - : embedding<is_embedded<typename C::value_type, T>::value> - { - template <typename N> - static constexpr auto apply(N const&) - { return integral_constant<T, N::value>{}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Optimizations - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct eval_if_impl<integral_constant_tag<T>> { - template <typename Cond, typename Then, typename Else> - static constexpr decltype(auto) - apply(Cond const&, Then&& t, Else&& e) { - constexpr bool cond = static_cast<bool>(Cond::value); - return eval_if_impl::apply(hana::bool_<cond>{}, - static_cast<Then&&>(t), - static_cast<Else&&>(e)); - } - - template <typename Then, typename Else> - static constexpr decltype(auto) - apply(hana::true_ const&, Then&& t, Else&&) - { return hana::eval(static_cast<Then&&>(t)); } - - template <typename Then, typename Else> - static constexpr decltype(auto) - apply(hana::false_ const&, Then&&, Else&& e) - { return hana::eval(static_cast<Else&&>(e)); } - }; - - template <typename T> - struct if_impl<integral_constant_tag<T>> { - template <typename Cond, typename Then, typename Else> - static constexpr decltype(auto) - apply(Cond const&, Then&& t, Else&& e) { - constexpr bool cond = static_cast<bool>(Cond::value); - return if_impl::apply(hana::bool_<cond>{}, - static_cast<Then&&>(t), - static_cast<Else&&>(e)); - } - - //! @todo We could return `Then` instead of `auto` to sometimes save - //! a copy, but that would break some code that would return a - //! reference to a `type` object. I think the code that would be - //! broken should be changed, but more thought needs to be given. - template <typename Then, typename Else> - static constexpr auto - apply(hana::true_ const&, Then&& t, Else&&) - { return static_cast<Then&&>(t); } - - template <typename Then, typename Else> - static constexpr auto - apply(hana::false_ const&, Then&&, Else&& e) - { return static_cast<Else&&>(e); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_BOOL_HPP diff --git a/contrib/restricted/boost/boost/hana/cartesian_product.hpp b/contrib/restricted/boost/boost/hana/cartesian_product.hpp deleted file mode 100644 index 556c3b5237..0000000000 --- a/contrib/restricted/boost/boost/hana/cartesian_product.hpp +++ /dev/null @@ -1,113 +0,0 @@ -/*! -@file -Defines `boost::hana::cartesian_product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CARTESIAN_PRODUCT_HPP -#define BOOST_HANA_CARTESIAN_PRODUCT_HPP - -#include <boost/hana/fwd/cartesian_product.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto cartesian_product_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using CartesianProduct = BOOST_HANA_DISPATCH_IF( - cartesian_product_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::cartesian_product(xs) requires 'xs' to be a Sequence"); - #endif - - return CartesianProduct::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - namespace detail { - template <std::size_t ...Lengths> - struct cartesian_product_indices { - static constexpr std::size_t total_length() { - std::size_t lengths[sizeof...(Lengths)] = {Lengths...}; - std::size_t r = 1; - for (std::size_t len: lengths) - r *= len; - return r; - } - - static constexpr std::size_t length = total_length(); - - static constexpr auto indices_of(std::size_t i) { - constexpr std::size_t lengths[sizeof...(Lengths)] = {Lengths...}; - constexpr std::size_t n = sizeof...(Lengths); - detail::array<std::size_t, n> result{}; - for (std::size_t j = n; j--;) { - result[j] = i % lengths[j]; - i /= lengths[j]; - } - return result; - } - - template <typename S, std::size_t n, std::size_t ...k, typename ...Xs> - static constexpr auto - product_element(std::index_sequence<k...>, Xs&& ...xs) { - constexpr auto indices = indices_of(n); - return hana::make<S>(hana::at_c<indices[k]>(xs)...); - } - - template <typename S, std::size_t ...n, typename ...Xs> - static constexpr auto - create_product(std::index_sequence<n...>, Xs&& ...xs) { - return hana::make<S>(product_element<S, n>( - std::make_index_sequence<sizeof...(Xs)>{}, xs... - )...); - } - }; - } - - // Credits: implementation adapted from http://github.com/alexk7/hel. - template <typename S, bool condition> - struct cartesian_product_impl<S, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs&& xs) { - return hana::unpack(static_cast<Xs&&>(xs), cartesian_product_impl{}); - } - - template <typename ...Xs> - constexpr auto operator()(Xs&& ...xs) const { - using indices = detail::cartesian_product_indices< - decltype(hana::length(xs))::value... - >; - return indices::template create_product<S>( - std::make_index_sequence<indices::length>{}, - static_cast<Xs&&>(xs)...); - } - - constexpr auto operator()() const { - return hana::make<S>(); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CARTESIAN_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/chain.hpp b/contrib/restricted/boost/boost/hana/chain.hpp deleted file mode 100644 index ab889d186a..0000000000 --- a/contrib/restricted/boost/boost/hana/chain.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Defines `boost::hana::chain`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CHAIN_HPP -#define BOOST_HANA_CHAIN_HPP - -#include <boost/hana/fwd/chain.hpp> - -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/flatten.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr decltype(auto) chain_t::operator()(Xs&& xs, F&& f) const { - using M = typename hana::tag_of<Xs>::type; - using Chain = BOOST_HANA_DISPATCH_IF(chain_impl<M>, - hana::Monad<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::chain(xs, f) requires 'xs' to be a Monad"); - #endif - - return Chain::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - template <typename M, bool condition> - struct chain_impl<M, when<condition>> : default_ { - template <typename Xs, typename F> - static constexpr auto apply(Xs&& xs, F&& f) { - return hana::flatten(hana::transform(static_cast<Xs&&>(xs), - static_cast<F&&>(f))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CHAIN_HPP diff --git a/contrib/restricted/boost/boost/hana/comparing.hpp b/contrib/restricted/boost/boost/hana/comparing.hpp deleted file mode 100644 index 4aaa546d4c..0000000000 --- a/contrib/restricted/boost/boost/hana/comparing.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*! -@file -Defines `boost::hana::comparing`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_COMPARING_HPP -#define BOOST_HANA_COMPARING_HPP - -#include <boost/hana/fwd/comparing.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/equal.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename F> - struct equal_by { - F f; - - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) const& - { return hana::equal(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } - - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) & - { return hana::equal(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } - }; - } - - //! @cond - template <typename F> - constexpr auto comparing_t::operator()(F&& f) const { - return detail::equal_by<typename detail::decay<F>::type>{static_cast<F&&>(f)}; - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_COMPARING_HPP diff --git a/contrib/restricted/boost/boost/hana/concat.hpp b/contrib/restricted/boost/boost/hana/concat.hpp deleted file mode 100644 index 27f2ad0bf2..0000000000 --- a/contrib/restricted/boost/boost/hana/concat.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/*! -@file -Defines `boost::hana::concat`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCAT_HPP -#define BOOST_HANA_CONCAT_HPP - -#include <boost/hana/fwd/concat.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto concat_t::operator()(Xs&& xs, Ys&& ys) const { - using M = typename hana::tag_of<Xs>::type; - using Concat = BOOST_HANA_DISPATCH_IF(concat_impl<M>, - hana::MonadPlus<M>::value && - std::is_same<typename hana::tag_of<Ys>::type, M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(std::is_same<typename hana::tag_of<Ys>::type, M>::value, - "hana::concat(xs, ys) requires 'xs' and 'ys' to have the same tag"); - - static_assert(hana::MonadPlus<M>::value, - "hana::concat(xs, ys) requires 'xs' and 'ys' to be MonadPlus"); - #endif - - return Concat::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename M, bool condition> - struct concat_impl<M, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S> - struct concat_impl<S, when<Sequence<S>::value>> { - template <typename Xs, typename Ys, std::size_t ...xi, std::size_t ...yi> - static constexpr auto - concat_helper(Xs&& xs, Ys&& ys, std::index_sequence<xi...>, - std::index_sequence<yi...>) - { - return hana::make<S>( - hana::at_c<xi>(static_cast<Xs&&>(xs))..., - hana::at_c<yi>(static_cast<Ys&&>(ys))... - ); - } - - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - constexpr std::size_t xi = decltype(hana::length(xs))::value; - constexpr std::size_t yi = decltype(hana::length(ys))::value; - return concat_helper(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), - std::make_index_sequence<xi>{}, - std::make_index_sequence<yi>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCAT_HPP diff --git a/contrib/restricted/boost/boost/hana/concept.hpp b/contrib/restricted/boost/boost/hana/concept.hpp deleted file mode 100644 index 6046b0a4ef..0000000000 --- a/contrib/restricted/boost/boost/hana/concept.hpp +++ /dev/null @@ -1,36 +0,0 @@ -/*! -@file -Master header for the `boost/hana/concept/` subdirectory. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_HPP -#define BOOST_HANA_CONCEPT_HPP - -#include <boost/hana/concept/applicative.hpp> -#include <boost/hana/concept/comonad.hpp> -#include <boost/hana/concept/comparable.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/euclidean_ring.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/concept/group.hpp> -#include <boost/hana/concept/hashable.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/concept/metafunction.hpp> -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/monoid.hpp> -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/concept/product.hpp> -#include <boost/hana/concept/ring.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/concept/struct.hpp> - -#endif // !BOOST_HANA_CONCEPT_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/applicative.hpp b/contrib/restricted/boost/boost/hana/concept/applicative.hpp deleted file mode 100644 index 84b92927eb..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/applicative.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Applicative`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_APPLICATIVE_HPP -#define BOOST_HANA_CONCEPT_APPLICATIVE_HPP - -#include <boost/hana/fwd/concept/applicative.hpp> - -#include <boost/hana/ap.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/lift.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename A> - struct Applicative - : hana::integral_constant<bool, - !is_default<ap_impl<typename tag_of<A>::type>>::value && - !is_default<lift_impl<typename tag_of<A>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_APPLICATIVE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/comonad.hpp b/contrib/restricted/boost/boost/hana/concept/comonad.hpp deleted file mode 100644 index 6cf950590f..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/comonad.hpp +++ /dev/null @@ -1,35 +0,0 @@ -/*! -@file -Defines `boost::hana::Comonad`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_COMONAD_HPP -#define BOOST_HANA_CONCEPT_COMONAD_HPP - -#include <boost/hana/fwd/concept/comonad.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/duplicate.hpp> -#include <boost/hana/extend.hpp> -#include <boost/hana/extract.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename W> - struct Comonad - : hana::integral_constant<bool, - !is_default<extract_impl<typename tag_of<W>::type>>::value && - (!is_default<duplicate_impl<typename tag_of<W>::type>>::value || - !is_default<extend_impl<typename tag_of<W>::type>>::value) - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_COMONAD_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/comparable.hpp b/contrib/restricted/boost/boost/hana/concept/comparable.hpp deleted file mode 100644 index bcecfcd0ab..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/comparable.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Defines `boost::hana::Comparable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_COMPARABLE_HPP -#define BOOST_HANA_CONCEPT_COMPARABLE_HPP - -#include <boost/hana/fwd/concept/comparable.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/equal.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename T> - struct Comparable - : hana::integral_constant<bool, - !is_default<equal_impl<typename tag_of<T>::type, - typename tag_of<T>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_COMPARABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/constant.hpp b/contrib/restricted/boost/boost/hana/concept/constant.hpp deleted file mode 100644 index 5e549ddf76..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/constant.hpp +++ /dev/null @@ -1,31 +0,0 @@ -/*! -@file -Defines `boost::hana::Constant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_CONSTANT_HPP -#define BOOST_HANA_CONCEPT_CONSTANT_HPP - -#include <boost/hana/fwd/concept/constant.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/value.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename C> - struct Constant - : hana::integral_constant<bool, - !is_default<value_impl<typename tag_of<C>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/euclidean_ring.hpp b/contrib/restricted/boost/boost/hana/concept/euclidean_ring.hpp deleted file mode 100644 index e0de0477b0..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/euclidean_ring.hpp +++ /dev/null @@ -1,35 +0,0 @@ -/*! -@file -Defines `boost::hana::EuclideanRing`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP -#define BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP - -#include <boost/hana/fwd/concept/euclidean_ring.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/div.hpp> -#include <boost/hana/mod.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename R> - struct EuclideanRing - : hana::integral_constant<bool, - !is_default<mod_impl<typename tag_of<R>::type, - typename tag_of<R>::type>>::value && - !is_default<div_impl<typename tag_of<R>::type, - typename tag_of<R>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_EUCLIDEAN_RING_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/foldable.hpp b/contrib/restricted/boost/boost/hana/concept/foldable.hpp deleted file mode 100644 index 6d88b58285..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/foldable.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Foldable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_FOLDABLE_HPP -#define BOOST_HANA_CONCEPT_FOLDABLE_HPP - -#include <boost/hana/fwd/concept/foldable.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename T> - struct Foldable - : hana::integral_constant<bool, - !is_default<fold_left_impl<typename tag_of<T>::type>>::value || - !is_default<unpack_impl<typename tag_of<T>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_FOLDABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/functor.hpp b/contrib/restricted/boost/boost/hana/concept/functor.hpp deleted file mode 100644 index 4fe7428b32..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/functor.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Functor`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_FUNCTOR_HPP -#define BOOST_HANA_CONCEPT_FUNCTOR_HPP - -#include <boost/hana/fwd/concept/functor.hpp> - -#include <boost/hana/adjust_if.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename F> - struct Functor - : hana::integral_constant<bool, - !is_default<transform_impl<typename tag_of<F>::type>>::value || - !is_default<adjust_if_impl<typename tag_of<F>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_FUNCTOR_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/group.hpp b/contrib/restricted/boost/boost/hana/concept/group.hpp deleted file mode 100644 index 2b16728b4f..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/group.hpp +++ /dev/null @@ -1,34 +0,0 @@ -/*! -@file -Defines `boost::hana::Group`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_GROUP_HPP -#define BOOST_HANA_CONCEPT_GROUP_HPP - -#include <boost/hana/fwd/concept/group.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/minus.hpp> -#include <boost/hana/negate.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename G> - struct Group - : hana::integral_constant<bool, - !is_default<negate_impl<typename tag_of<G>::type>>::value || - !is_default<minus_impl<typename tag_of<G>::type, - typename tag_of<G>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_GROUP_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/hashable.hpp b/contrib/restricted/boost/boost/hana/concept/hashable.hpp deleted file mode 100644 index b5a0ca0feb..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/hashable.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Defines `boost::hana::Hashable`. - -@copyright Louis Dionne 2016 -@copyright Jason Rice 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) - */ - -#ifndef BOOST_HANA_CONCEPT_HASHABLE_HPP -#define BOOST_HANA_CONCEPT_HASHABLE_HPP - -#include <boost/hana/fwd/concept/hashable.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/hash.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename T> - struct Hashable - : hana::integral_constant<bool, - !is_default<hash_impl<typename tag_of<T>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_HASHABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/integral_constant.hpp b/contrib/restricted/boost/boost/hana/concept/integral_constant.hpp deleted file mode 100644 index cfb761da9b..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/integral_constant.hpp +++ /dev/null @@ -1,43 +0,0 @@ -/*! -@file -Defines `boost::hana::IntegralConstant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/fwd/concept/integral_constant.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename C, typename Tag = typename tag_of<C>::type> - struct integral_constant_dispatch - : hana::integral_constant<bool, - hana::IntegralConstant<Tag>::value - > - { }; - - template <typename C> - struct integral_constant_dispatch<C, C> - : hana::integral_constant<bool, false> - { }; - } - - //! @cond - template <typename C> - struct IntegralConstant - : detail::integral_constant_dispatch<C> - { }; - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/iterable.hpp b/contrib/restricted/boost/boost/hana/concept/iterable.hpp deleted file mode 100644 index 2949f70b2b..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/iterable.hpp +++ /dev/null @@ -1,35 +0,0 @@ -/*! -@file -Defines `boost::hana::Iterable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_ITERABLE_HPP -#define BOOST_HANA_CONCEPT_ITERABLE_HPP - -#include <boost/hana/fwd/concept/iterable.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/is_empty.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename It> - struct Iterable - : hana::integral_constant<bool, - !is_default<at_impl<typename tag_of<It>::type>>::value && - !is_default<drop_front_impl<typename tag_of<It>::type>>::value && - !is_default<is_empty_impl<typename tag_of<It>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_ITERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/logical.hpp b/contrib/restricted/boost/boost/hana/concept/logical.hpp deleted file mode 100644 index 69e3079065..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/logical.hpp +++ /dev/null @@ -1,35 +0,0 @@ -/*! -@file -Defines `boost::hana::Logical`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_LOGICAL_HPP -#define BOOST_HANA_CONCEPT_LOGICAL_HPP - -#include <boost/hana/fwd/concept/logical.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/eval_if.hpp> -#include <boost/hana/not.hpp> -#include <boost/hana/while.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename L> - struct Logical - : hana::integral_constant<bool, - !is_default<eval_if_impl<typename tag_of<L>::type>>::value && - !is_default<not_impl<typename tag_of<L>::type>>::value && - !is_default<while_impl<typename tag_of<L>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_LOGICAL_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/metafunction.hpp b/contrib/restricted/boost/boost/hana/concept/metafunction.hpp deleted file mode 100644 index 70a9b0092a..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/metafunction.hpp +++ /dev/null @@ -1,41 +0,0 @@ -/*! -@file -Defines `boost::hana::Metafunction`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_METAFUNCTION_HPP -#define BOOST_HANA_CONCEPT_METAFUNCTION_HPP - -#include <boost/hana/fwd/concept/metafunction.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename F, typename Tag = typename tag_of<F>::type> - struct metafunction_dispatch - : hana::integral_constant<bool, - Metafunction<Tag>::value - > - { }; - - template <typename F> - struct metafunction_dispatch<F, F> - : hana::integral_constant<bool, false> - { }; - } - - template <typename F> - struct Metafunction - : detail::metafunction_dispatch<F> - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_METAFUNCTION_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/monad.hpp b/contrib/restricted/boost/boost/hana/concept/monad.hpp deleted file mode 100644 index 85fa06f9c3..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/monad.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Monad`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_MONAD_HPP -#define BOOST_HANA_CONCEPT_MONAD_HPP - -#include <boost/hana/fwd/concept/monad.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/flatten.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct Monad - : hana::integral_constant<bool, - !is_default<flatten_impl<typename tag_of<M>::type>>::value || - !is_default<chain_impl<typename tag_of<M>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_MONAD_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/monad_plus.hpp b/contrib/restricted/boost/boost/hana/concept/monad_plus.hpp deleted file mode 100644 index e9f2f1bf09..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/monad_plus.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::MonadPlus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_MONAD_PLUS_HPP -#define BOOST_HANA_CONCEPT_MONAD_PLUS_HPP - -#include <boost/hana/fwd/concept/monad_plus.hpp> - -#include <boost/hana/concat.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/empty.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct MonadPlus - : hana::integral_constant<bool, - !is_default<concat_impl<typename tag_of<M>::type>>::value && - !is_default<empty_impl<typename tag_of<M>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_MONAD_PLUS_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/monoid.hpp b/contrib/restricted/boost/boost/hana/concept/monoid.hpp deleted file mode 100644 index adda475a26..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/monoid.hpp +++ /dev/null @@ -1,34 +0,0 @@ -/*! -@file -Defines `boost::hana::Monoid`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_MONOID_HPP -#define BOOST_HANA_CONCEPT_MONOID_HPP - -#include <boost/hana/fwd/concept/monoid.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/plus.hpp> -#include <boost/hana/zero.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct Monoid - : hana::integral_constant<bool, - !is_default<zero_impl<typename tag_of<M>::type>>::value && - !is_default<plus_impl<typename tag_of<M>::type, - typename tag_of<M>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_MONOID_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/orderable.hpp b/contrib/restricted/boost/boost/hana/concept/orderable.hpp deleted file mode 100644 index dfa82655fc..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/orderable.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Defines `boost::hana::Orderable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_ORDERABLE_HPP -#define BOOST_HANA_CONCEPT_ORDERABLE_HPP - -#include <boost/hana/fwd/concept/orderable.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename Ord> - struct Orderable - : hana::integral_constant<bool, - !is_default<less_impl<typename tag_of<Ord>::type, - typename tag_of<Ord>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_ORDERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/product.hpp b/contrib/restricted/boost/boost/hana/concept/product.hpp deleted file mode 100644 index b1292ba156..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/product.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_PRODUCT_HPP -#define BOOST_HANA_CONCEPT_PRODUCT_HPP - -#include <boost/hana/fwd/concept/product.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/second.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename P> - struct Product - : hana::integral_constant<bool, - !is_default<first_impl<typename tag_of<P>::type>>::value && - !is_default<second_impl<typename tag_of<P>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/ring.hpp b/contrib/restricted/boost/boost/hana/concept/ring.hpp deleted file mode 100644 index a9598e8fb3..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/ring.hpp +++ /dev/null @@ -1,34 +0,0 @@ -/*! -@file -Defines `boost::hana::Ring`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_RING_HPP -#define BOOST_HANA_CONCEPT_RING_HPP - -#include <boost/hana/fwd/concept/ring.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/mult.hpp> -#include <boost/hana/one.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename R> - struct Ring - : hana::integral_constant<bool, - !is_default<one_impl<typename tag_of<R>::type>>::value && - !is_default<mult_impl<typename tag_of<R>::type, - typename tag_of<R>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_RING_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/searchable.hpp b/contrib/restricted/boost/boost/hana/concept/searchable.hpp deleted file mode 100644 index 65b161de73..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/searchable.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::Searchable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_SEARCHABLE_HPP -#define BOOST_HANA_CONCEPT_SEARCHABLE_HPP - -#include <boost/hana/fwd/concept/searchable.hpp> - -#include <boost/hana/any_of.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> -#include <boost/hana/find_if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename S> - struct Searchable - : hana::integral_constant<bool, - !is_default<any_of_impl<typename tag_of<S>::type>>::value && - !is_default<find_if_impl<typename tag_of<S>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_SEARCHABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/sequence.hpp b/contrib/restricted/boost/boost/hana/concept/sequence.hpp deleted file mode 100644 index 83e4b42d3d..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/sequence.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*! -@file -Defines `boost::hana::Sequence`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_SEQUENCE_HPP -#define BOOST_HANA_CONCEPT_SEQUENCE_HPP - -#include <boost/hana/fwd/concept/sequence.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename S, typename Tag = typename hana::tag_of<S>::type> - struct sequence_dispatch - : hana::integral_constant<bool, - hana::Sequence<Tag>::value - > - { }; - - template <typename S> - struct sequence_dispatch<S, S> - : hana::integral_constant<bool, false> - { }; - } - - //! @cond - template <typename S, bool condition> - struct Sequence<S, when<condition>> - : detail::sequence_dispatch<S> - { }; - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_SEQUENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/concept/struct.hpp b/contrib/restricted/boost/boost/hana/concept/struct.hpp deleted file mode 100644 index 49ac53b59c..0000000000 --- a/contrib/restricted/boost/boost/hana/concept/struct.hpp +++ /dev/null @@ -1,31 +0,0 @@ -/*! -@file -Defines `boost::hana::Struct`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONCEPT_STRUCT_HPP -#define BOOST_HANA_CONCEPT_STRUCT_HPP - -#include <boost/hana/fwd/concept/struct.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename S> - struct Struct - : hana::integral_constant<bool, - !is_default<accessors_impl<typename tag_of<S>::type>>::value - > - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONCEPT_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/config.hpp b/contrib/restricted/boost/boost/hana/config.hpp deleted file mode 100644 index f47cf739a1..0000000000 --- a/contrib/restricted/boost/boost/hana/config.hpp +++ /dev/null @@ -1,219 +0,0 @@ -/*! -@file -Defines configuration macros used throughout the library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONFIG_HPP -#define BOOST_HANA_CONFIG_HPP - -#include <boost/hana/version.hpp> - - -////////////////////////////////////////////////////////////////////////////// -// Detect the compiler -////////////////////////////////////////////////////////////////////////////// - -#if defined(_MSC_VER) && !defined(__clang__) // MSVC - // This must be checked first, because otherwise it produces a fatal - // error due to unrecognized #warning directives used below. -# pragma message("Warning: the native Microsoft compiler is not supported due to lack of proper C++14 support.") - -#elif defined(__clang__) && defined(_MSC_VER) // Clang-cl (Clang for Windows) - -# define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION( \ - __clang_major__, __clang_minor__, __clang_patchlevel__) - -# if BOOST_HANA_CONFIG_CLANG < BOOST_HANA_CONFIG_VERSION(3, 5, 0) -# warning "Versions of Clang prior to 3.5.0 are not supported by Hana." -# endif - -# if _MSC_VER < 1900 -# warning "Clang-cl is only supported with the -fms-compatibility-version parameter set to 19 and above." -# endif - -#elif defined(__clang__) && defined(__apple_build_version__) // Apple's Clang - -# if __apple_build_version__ >= 6020049 -# define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION(3, 6, 0) -# else -# warning "Versions of Apple's Clang prior to the one shipped with Xcode 6.3 are not supported by Hana." -# endif - -#elif defined(__clang__) // genuine Clang - -# define BOOST_HANA_CONFIG_CLANG BOOST_HANA_CONFIG_VERSION( \ - __clang_major__, __clang_minor__, __clang_patchlevel__) - -# if BOOST_HANA_CONFIG_CLANG < BOOST_HANA_CONFIG_VERSION(3, 5, 0) -# warning "Versions of Clang prior to 3.5.0 are not supported by Hana." -# endif - -#elif defined(__GNUC__) // GCC - -# define BOOST_HANA_CONFIG_GCC BOOST_HANA_CONFIG_VERSION( \ - __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) - -# if BOOST_HANA_CONFIG_GCC < BOOST_HANA_CONFIG_VERSION(6, 0, 0) -# warning "Versions of GCC prior to 6.0.0 are not supported by Hana." -# endif - -#else - -# warning "Your compiler is not officially supported by Hana or it was not detected properly." - -#endif - -////////////////////////////////////////////////////////////////////////////// -// Check the compiler for general C++14 capabilities -////////////////////////////////////////////////////////////////////////////// -#if (__cplusplus < 201400) -# if defined(_MSC_VER) -# pragma message("Warning: Your compiler doesn't provide C++14 or higher capabilities. Try adding the compiler flag '-std=c++14' or '-std=c++1y'.") -# else -# warning "Your compiler doesn't provide C++14 or higher capabilities. Try adding the compiler flag '-std=c++14' or '-std=c++1y'." -# endif -#endif - -////////////////////////////////////////////////////////////////////////////// -// Detect the standard library -////////////////////////////////////////////////////////////////////////////// - -// We include this header, which normally defines the proper detection macros. -// At least, libc++ and libstdc++ do. -#include <cstddef> - -#if defined(_LIBCPP_VERSION) - -# define BOOST_HANA_CONFIG_LIBCPP BOOST_HANA_CONFIG_VERSION( \ - (_LIBCPP_VERSION) / 1000, 0, (_LIBCPP_VERSION) % 1000) - -# if BOOST_HANA_CONFIG_LIBCPP < BOOST_HANA_CONFIG_VERSION(1, 0, 101) -# warning "Versions of libc++ prior to the one shipped with Clang 3.5.0 are not supported by Hana." -# endif - -#elif defined(__GLIBCXX__) - -// We do not define a macro to keep track of libstdc++'s version, because -// we have no scalable way of associating a value of __GLIBCXX__ to the -// corresponding GCC release. Instead, we just check that the release date -// of the libstdc++ in use is recent enough, which should indicate that it -// was released with a GCC >= 5.1, which in turn indicates good enough C++14 -// support. -# if __GLIBCXX__ < 20150422 // --> the libstdc++ shipped with GCC 5.1.0 -# warning "Versions of libstdc++ prior to the one shipped with GCC 5.1.0 are not supported by Hana for lack of full C++14 support." -# endif - -# define BOOST_HANA_CONFIG_LIBSTDCXX - -#elif defined(_MSC_VER) - -# define BOOST_HANA_CONFIG_LIBMSVCCXX - -#else - -# warning "Your standard library is not officially supported by Hana or it was not detected properly." - -#endif - - -////////////////////////////////////////////////////////////////////////////// -// Caveats and other compiler-dependent options -////////////////////////////////////////////////////////////////////////////// - -// `BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA` enables some constructs requiring -// `constexpr` lambdas, which are in the language starting with C++17. -// -// Always disabled for now because Clang only has partial support for them -// (captureless lambdas only). -#if defined(__cplusplus) && __cplusplus > 201402L -# define BOOST_HANA_CONSTEXPR_STATELESS_LAMBDA constexpr -// # define BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA -#else -# define BOOST_HANA_CONSTEXPR_STATELESS_LAMBDA /* nothing */ -#endif - -// `BOOST_HANA_CONSTEXPR_LAMBDA` expands to `constexpr` if constexpr lambdas -// are supported and to nothing otherwise. -#if defined(BOOST_HANA_CONFIG_HAS_CONSTEXPR_LAMBDA) -# define BOOST_HANA_CONSTEXPR_LAMBDA constexpr -#else -# define BOOST_HANA_CONSTEXPR_LAMBDA /* nothing */ -#endif - -// There's a bug in std::tuple_cat in libc++ right now. -// See http://llvm.org/bugs/show_bug.cgi?id=22806. -#if defined(BOOST_HANA_CONFIG_LIBCPP) -# define BOOST_HANA_CONFIG_LIBCPP_HAS_BUG_22806 -#endif - -////////////////////////////////////////////////////////////////////////////// -// Namespace macros -////////////////////////////////////////////////////////////////////////////// -#define BOOST_HANA_NAMESPACE_BEGIN namespace boost { namespace hana { - -#define BOOST_HANA_NAMESPACE_END }} - -////////////////////////////////////////////////////////////////////////////// -// Library features and options that can be tweaked by users -////////////////////////////////////////////////////////////////////////////// - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) || \ - (defined(NDEBUG) && !defined(BOOST_HANA_CONFIG_DISABLE_ASSERTIONS)) - //! @ingroup group-config - //! Disables the `BOOST_HANA_*_ASSERT` macro & friends. - //! - //! When this macro is defined, the `BOOST_HANA_*_ASSERT` macro & friends - //! are disabled, i.e. they expand to nothing. - //! - //! This macro is defined automatically when `NDEBUG` is defined. It can - //! also be defined by users before including this header or defined on - //! the command line. -# define BOOST_HANA_CONFIG_DISABLE_ASSERTIONS -#endif - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - //! @ingroup group-config - //! Disables concept checks in interface methods. - //! - //! When this macro is not defined (the default), tag-dispatched methods - //! will make sure the arguments they are passed are models of the proper - //! concept(s). This can be very helpful in catching programming errors, - //! but it is also slightly less compile-time efficient. You should - //! probably always leave the checks enabled (and hence never define this - //! macro), except perhaps in translation units that are compiled very - //! often but whose code using Hana is modified very rarely. -# define BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS -#endif - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - //! @ingroup group-config - //! Enables usage of the "string literal operator template" GNU extension. - //! - //! That operator is not part of the language yet, but it is supported by - //! both Clang and GCC. This operator allows Hana to provide the nice `_s` - //! user-defined literal for creating compile-time strings. - //! - //! When this macro is not defined, the GNU extension will be not used - //! by Hana. Because this is a non-standard extension, the macro is not - //! defined by default. -# define BOOST_HANA_CONFIG_ENABLE_STRING_UDL -#endif - -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - //! @ingroup group-config - //! Enables additional assertions and sanity checks to be done by Hana. - //! - //! When this macro is defined (it is __not defined__ by default), - //! additional sanity checks may be done by Hana. These checks may - //! be costly to perform, either in terms of compilation time or in - //! terms of execution time. These checks may help debugging an - //! application during its initial development, but they should not - //! be enabled as part of the normal configuration. -# define BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE -#endif - -#endif // !BOOST_HANA_CONFIG_HPP diff --git a/contrib/restricted/boost/boost/hana/contains.hpp b/contrib/restricted/boost/boost/hana/contains.hpp deleted file mode 100644 index 5e18a388dc..0000000000 --- a/contrib/restricted/boost/boost/hana/contains.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines `boost::hana::contains` and `boost::hana::in`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CONTAINS_HPP -#define BOOST_HANA_CONTAINS_HPP - -#include <boost/hana/fwd/contains.hpp> - -#include <boost/hana/any_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/equal.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Key> - constexpr auto contains_t::operator()(Xs&& xs, Key&& key) const { - using S = typename hana::tag_of<Xs>::type; - using Contains = BOOST_HANA_DISPATCH_IF(contains_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::contains(xs, key) requires 'xs' to be a Searchable"); - #endif - - return Contains::apply(static_cast<Xs&&>(xs), - static_cast<Key&&>(key)); - } - //! @endcond - - template <typename S, bool condition> - struct contains_impl<S, when<condition>> : default_ { - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - return hana::any_of(static_cast<Xs&&>(xs), - hana::equal.to(static_cast<X&&>(x))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CONTAINS_HPP diff --git a/contrib/restricted/boost/boost/hana/core.hpp b/contrib/restricted/boost/boost/hana/core.hpp deleted file mode 100644 index fa280f3336..0000000000 --- a/contrib/restricted/boost/boost/hana/core.hpp +++ /dev/null @@ -1,22 +0,0 @@ -/*! -@file -Defines the @ref group-core module. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_HPP -#define BOOST_HANA_CORE_HPP - -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/is_a.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/core/when.hpp> - -#endif // !BOOST_HANA_CORE_HPP diff --git a/contrib/restricted/boost/boost/hana/core/common.hpp b/contrib/restricted/boost/boost/hana/core/common.hpp deleted file mode 100644 index c32de77feb..0000000000 --- a/contrib/restricted/boost/boost/hana/core/common.hpp +++ /dev/null @@ -1,109 +0,0 @@ -/*! -@file -Defines `boost::hana::common` and `boost::hana::common_t`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_COMMON_HPP -#define BOOST_HANA_CORE_COMMON_HPP - -#include <boost/hana/fwd/core/common.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/std_common_type.hpp> -#include <boost/hana/detail/void_t.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // common - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename T, typename U, typename> - struct common : common<T, U, when<true>> { }; - //! @endcond - - template <typename T, typename U, bool condition> - struct common<T, U, when<condition>> - : detail::std_common_type<T, U> - { }; - - template <typename T> - struct common<T, T> { - using type = T; - }; - - ////////////////////////////////////////////////////////////////////////// - // has_common - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U, typename> - struct has_common : std::false_type { }; - - template <typename T, typename U> - struct has_common<T, U, detail::void_t<typename common<T, U>::type>> - : std::true_type - { }; - - ////////////////////////////////////////////////////////////////////////// - // Provided common data types for Constants - ////////////////////////////////////////////////////////////////////////// - namespace constant_detail { - //! @todo - //! This is an awful hack to avoid having - //! @code - //! common<integral_constant_tag<int>, integral_constant_tag<long>> - //! == - //! CanonicalConstant<long> - //! @endcode - template <typename A, typename B, typename C> - struct which { - using type = detail::CanonicalConstant<C>; - }; - - template <template <typename ...> class A, typename T, typename U, typename C> - struct which<A<T>, A<U>, C> { - using type = A<C>; - }; - } - - template <typename A, typename B> - struct common<A, B, when< - hana::Constant<A>::value && - hana::Constant<B>::value && - has_common<typename A::value_type, typename B::value_type>::value - >> { - using type = typename constant_detail::which< - A, B, - typename common<typename A::value_type, - typename B::value_type>::type - >::type; - }; - - template <typename A, typename B> - struct common<A, B, when< - hana::Constant<A>::value && - !hana::Constant<B>::value && - has_common<typename A::value_type, B>::value - >> { - using type = typename common<typename A::value_type, B>::type; - }; - - template <typename A, typename B> - struct common<A, B, when< - !hana::Constant<A>::value && - hana::Constant<B>::value && - has_common<A, typename B::value_type>::value - >> { - using type = typename common<A, typename B::value_type>::type; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_COMMON_HPP diff --git a/contrib/restricted/boost/boost/hana/core/default.hpp b/contrib/restricted/boost/boost/hana/core/default.hpp deleted file mode 100644 index 45c70503c1..0000000000 --- a/contrib/restricted/boost/boost/hana/core/default.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Defines `boost::hana::default_` and `boost::hana::is_default`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_DEFAULT_HPP -#define BOOST_HANA_CORE_DEFAULT_HPP - -#include <boost/hana/fwd/core/default.hpp> - -#include <boost/hana/config.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename Method, typename> - struct is_default : std::false_type { }; - - template <typename Method> - struct is_default<Method, decltype((void) - static_cast<default_>(*(Method*)0) - )> - : std::true_type - { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_DEFAULT_HPP diff --git a/contrib/restricted/boost/boost/hana/core/dispatch.hpp b/contrib/restricted/boost/boost/hana/core/dispatch.hpp deleted file mode 100644 index 27a2fb493b..0000000000 --- a/contrib/restricted/boost/boost/hana/core/dispatch.hpp +++ /dev/null @@ -1,18 +0,0 @@ -/*! -@file -Includes all the headers needed to setup tag-dispatching. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_DISPATCH_HPP -#define BOOST_HANA_CORE_DISPATCH_HPP - -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/dispatch_if.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/when.hpp> - -#endif // !BOOST_HANA_CORE_DISPATCH_HPP diff --git a/contrib/restricted/boost/boost/hana/core/is_a.hpp b/contrib/restricted/boost/boost/hana/core/is_a.hpp deleted file mode 100644 index 019476ff0a..0000000000 --- a/contrib/restricted/boost/boost/hana/core/is_a.hpp +++ /dev/null @@ -1,41 +0,0 @@ -/*! -@file -Defines `boost::hana::is_a` and `boost::hana::is_an`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_IS_A_HPP -#define BOOST_HANA_CORE_IS_A_HPP - -#include <boost/hana/fwd/core/is_a.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // is_a - ////////////////////////////////////////////////////////////////////////// - template <typename DataType, typename T> - struct is_a_t<DataType, T> - : integral_constant<bool, - std::is_same<DataType, typename hana::tag_of<T>::type>::value - > - { }; - - template <typename DataType> - struct is_a_t<DataType> { - template <typename T> - constexpr auto operator()(T const&) const - { return hana::is_a<DataType, T>; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_IS_A_HPP diff --git a/contrib/restricted/boost/boost/hana/core/make.hpp b/contrib/restricted/boost/boost/hana/core/make.hpp deleted file mode 100644 index 30d21e337e..0000000000 --- a/contrib/restricted/boost/boost/hana/core/make.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::make`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_MAKE_HPP -#define BOOST_HANA_CORE_MAKE_HPP - -#include <boost/hana/fwd/core/make.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/default.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Datatype, typename> - struct make_impl : make_impl<Datatype, when<true>> { }; - //! @endcond - - template <typename Datatype, bool condition> - struct make_impl<Datatype, when<condition>> : default_ { - template <typename ...X> - static constexpr auto make_helper(int, X&& ...x) - -> decltype(Datatype(static_cast<X&&>(x)...)) - { return Datatype(static_cast<X&&>(x)...); } - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunused-value" - template <typename ...X> - static constexpr auto make_helper(long, X&& ...) { - static_assert((sizeof...(X), false), - "there exists no constructor for the given data type"); - } -#pragma clang diagnostic pop - - template <typename ...X> - static constexpr decltype(auto) apply(X&& ...x) - { return make_helper(int{}, static_cast<X&&>(x)...); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_MAKE_HPP diff --git a/contrib/restricted/boost/boost/hana/core/tag_of.hpp b/contrib/restricted/boost/boost/hana/core/tag_of.hpp deleted file mode 100644 index 87406521cd..0000000000 --- a/contrib/restricted/boost/boost/hana/core/tag_of.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/*! -@file -Defines `boost::hana::tag_of` and `boost::hana::tag_of_t`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_TAG_OF_HPP -#define BOOST_HANA_CORE_TAG_OF_HPP - -#include <boost/hana/fwd/core/tag_of.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename T, typename> - struct tag_of : tag_of<T, when<true>> { }; - //! @endcond - - namespace core_detail { - template <typename ...> - struct is_valid { static constexpr bool value = true; }; - } - - template <typename T, bool condition> - struct tag_of<T, when<condition>> { - using type = T; - }; - - template <typename T> - struct tag_of<T, when< - core_detail::is_valid<typename T::hana_tag>::value - >> { - using type = typename T::hana_tag; - }; - - template <typename T> struct tag_of<T const> : tag_of<T> { }; - template <typename T> struct tag_of<T volatile> : tag_of<T> { }; - template <typename T> struct tag_of<T const volatile> : tag_of<T> { }; - template <typename T> struct tag_of<T&> : tag_of<T> { }; - template <typename T> struct tag_of<T&&> : tag_of<T> { }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_TAG_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/core/to.hpp b/contrib/restricted/boost/boost/hana/core/to.hpp deleted file mode 100644 index 1b54115162..0000000000 --- a/contrib/restricted/boost/boost/hana/core/to.hpp +++ /dev/null @@ -1,196 +0,0 @@ -/*! -@file -Defines `boost::hana::to` and related utilities. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_TO_HPP -#define BOOST_HANA_CORE_TO_HPP - -#include <boost/hana/fwd/core/to.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/wrong.hpp> -#include <boost/hana/unpack.hpp> -#include <boost/hana/value.hpp> - -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // to - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename To, typename From, typename> - struct to_impl : to_impl<To, From, when<true>> { }; - //! @endcond - - namespace convert_detail { - struct no_conversion { }; - - template <typename To, typename From, typename = void> - struct maybe_static_cast : no_conversion { - template <typename X> - static constexpr auto apply(X const&) { - static_assert(detail::wrong<to_impl<To, From>, X>{}, - "no conversion is available between the provided types"); - } - }; - - template <typename To, typename From> - struct maybe_static_cast<To, From, decltype((void) - static_cast<To>(std::declval<From>()) - )> { - template <typename X> - static constexpr To apply(X&& x) - { return static_cast<To>(static_cast<X&&>(x)); } - }; - } // end namespace convert_detail - - template <typename To, typename From, bool condition> - struct to_impl<To, From, when<condition>> - : convert_detail::maybe_static_cast<To, From> - { }; - - template <typename To> - struct to_impl<To, To> : embedding<> { - template <typename X> - static constexpr X apply(X&& x) - { return static_cast<X&&>(x); } - }; - - //! @cond - template <typename To> - template <typename X> - constexpr decltype(auto) to_t<To>::operator()(X&& x) const { - using From = typename hana::tag_of<X>::type; - return to_impl<To, From>::apply(static_cast<X&&>(x)); - } - //! @endcond - -#define BOOST_HANA_DEFINE_EMBEDDING_IMPL(TO, FROM) \ - template <> \ - struct to_impl<TO, FROM> : embedding<> \ - { static constexpr TO apply(FROM x) { return x; } } \ -/**/ - BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, double); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(long double, float); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(double , float); - - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed long); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed int); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long long, signed char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed int); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed long , signed char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed int , signed char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(signed short , signed char); - - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned long); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned int); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long long, unsigned char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned int); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned long , unsigned char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned short); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned int , unsigned char); - BOOST_HANA_DEFINE_EMBEDDING_IMPL(unsigned short , unsigned char); -#undef BOOST_HANA_DEFINE_EMBEDDING_IMPL - - namespace detail { - template <typename T> - struct copy_char_signedness { - using type = typename std::conditional<std::is_signed<char>::value, - std::make_signed<T>, std::make_unsigned<T> - >::type::type; - }; - } - - // If `char` is signed, we define an embedding from `char` to any signed - // integral type. Otherwise, we define one from `char` to any unsigned - // integral type. -#define BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(TO) \ - template <> \ - struct to_impl<detail::copy_char_signedness<TO>::type, char> \ - : embedding<> \ - { \ - static constexpr detail::copy_char_signedness<TO>::type \ - apply(char x) \ - { return x; } \ - } \ -/**/ - BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long long); - BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(long); - BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(int); - BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL(short); -#undef BOOST_HANA_DEFINE_CHAR_EMBEDDING_IMPL - - template <typename T> - struct to_impl<T*, decltype(nullptr)> : embedding<> { - static constexpr T* apply(decltype(nullptr)) { return nullptr; } - }; - - ////////////////////////////////////////////////////////////////////////// - // is_convertible - ////////////////////////////////////////////////////////////////////////// - template <typename From, typename To, typename> - struct is_convertible : std::true_type { }; - - template <typename From, typename To> - struct is_convertible<From, To, decltype((void) - static_cast<convert_detail::no_conversion>(*(to_impl<To, From>*)0) - )> : std::false_type { }; - - ////////////////////////////////////////////////////////////////////////// - // is_embedded - ////////////////////////////////////////////////////////////////////////// - template <typename From, typename To, typename> - struct is_embedded : std::false_type { }; - - template <typename From, typename To> - struct is_embedded<From, To, decltype((void) - static_cast<embedding<true>>(*(to_impl<To, From>*)0) - )> : std::true_type { }; - - ////////////////////////////////////////////////////////////////////////// - // Conversion for Constants - ////////////////////////////////////////////////////////////////////////// - template <typename To, typename From> - struct to_impl<To, From, when< - hana::Constant<From>::value && - is_convertible<typename From::value_type, To>::value - >> : embedding<is_embedded<typename From::value_type, To>::value> { - template <typename X> - static constexpr decltype(auto) apply(X const&) - { return hana::to<To>(hana::value<X>()); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable -> Sequence - ////////////////////////////////////////////////////////////////////////// - template <typename S, typename F> - struct to_impl<S, F, when< - hana::Sequence<S>::value && - hana::Foldable<F>::value - >> : embedding<Sequence<F>::value> { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) - { return hana::unpack(static_cast<Xs&&>(xs), hana::make<S>); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CORE_TO_HPP diff --git a/contrib/restricted/boost/boost/hana/core/when.hpp b/contrib/restricted/boost/boost/hana/core/when.hpp deleted file mode 100644 index 0e5ee8e4e0..0000000000 --- a/contrib/restricted/boost/boost/hana/core/when.hpp +++ /dev/null @@ -1,15 +0,0 @@ -/*! -@file -Defines `boost::hana::when` and `boost::hana::when_valid`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CORE_WHEN_HPP -#define BOOST_HANA_CORE_WHEN_HPP - -#include <boost/hana/fwd/core/when.hpp> - -#endif // !BOOST_HANA_CORE_WHEN_HPP diff --git a/contrib/restricted/boost/boost/hana/count.hpp b/contrib/restricted/boost/boost/hana/count.hpp deleted file mode 100644 index b912c342db..0000000000 --- a/contrib/restricted/boost/boost/hana/count.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Defines `boost::hana::count`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_COUNT_HPP -#define BOOST_HANA_COUNT_HPP - -#include <boost/hana/fwd/count.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/count_if.hpp> -#include <boost/hana/equal.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Value> - constexpr auto count_t::operator()(Xs&& xs, Value&& value) const { - using S = typename hana::tag_of<Xs>::type; - using Count = BOOST_HANA_DISPATCH_IF(count_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::count(xs, value) requires 'xs' to be Foldable"); - #endif - - return Count::apply(static_cast<Xs&&>(xs), static_cast<Value&&>(value)); - } - //! @endcond - - template <typename T, bool condition> - struct count_impl<T, when<condition>> : default_ { - template <typename Xs, typename Value> - static constexpr auto apply(Xs&& xs, Value&& value) { - return hana::count_if(static_cast<Xs&&>(xs), - hana::equal.to(static_cast<Value&&>(value))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_COUNT_HPP diff --git a/contrib/restricted/boost/boost/hana/count_if.hpp b/contrib/restricted/boost/boost/hana/count_if.hpp deleted file mode 100644 index e9ea4bc9c8..0000000000 --- a/contrib/restricted/boost/boost/hana/count_if.hpp +++ /dev/null @@ -1,92 +0,0 @@ -/*! -@file -Defines `boost::hana::count_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_COUNT_IF_HPP -#define BOOST_HANA_COUNT_IF_HPP - -#include <boost/hana/fwd/count_if.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto count_if_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using CountIf = BOOST_HANA_DISPATCH_IF(count_if_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::count_if(xs, pred) requires 'xs' to be Foldable"); - #endif - - return CountIf::apply(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - //! @endcond - - namespace detail { - template <typename Pred> - struct count_pred { - Pred pred; - template <typename ...Xs, typename = typename std::enable_if< - detail::fast_and< - Constant<decltype((*pred)(std::declval<Xs&&>()))>::value... - >::value - >::type> - constexpr auto operator()(Xs&& ...xs) const { - constexpr bool results[] = {false, // <-- avoid empty array - static_cast<bool>(hana::value<decltype((*pred)(static_cast<Xs&&>(xs)))>())... - }; - constexpr std::size_t total = detail::count( - results, results + sizeof(results), true - ); - return hana::size_c<total>; - } - - template <typename ...Xs, typename = void, typename = typename std::enable_if< - !detail::fast_and< - Constant<decltype((*pred)(std::declval<Xs&&>()))>::value... - >::value - >::type> - constexpr auto operator()(Xs&& ...xs) const { - std::size_t total = 0; - using Swallow = std::size_t[]; - (void)Swallow{0, ((*pred)(static_cast<Xs&&>(xs)) ? ++total : 0)...}; - return total; - } - }; - } - - template <typename T, bool condition> - struct count_if_impl<T, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr decltype(auto) apply(Xs&& xs, Pred&& pred) { - // We use a pointer instead of a reference to avoid a Clang ICE. - return hana::unpack(static_cast<Xs&&>(xs), - detail::count_pred<decltype(&pred)>{&pred} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_COUNT_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/cycle.hpp b/contrib/restricted/boost/boost/hana/cycle.hpp deleted file mode 100644 index c7b7a9ee32..0000000000 --- a/contrib/restricted/boost/boost/hana/cycle.hpp +++ /dev/null @@ -1,127 +0,0 @@ -/*! -@file -Defines `boost::hana::cycle`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_CYCLE_HPP -#define BOOST_HANA_CYCLE_HPP - -#include <boost/hana/fwd/cycle.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concat.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto cycle_t::operator()(Xs&& xs, N const& n) const { - using M = typename hana::tag_of<Xs>::type; - using Cycle = BOOST_HANA_DISPATCH_IF(cycle_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::cycle(xs, n) requires 'xs' to be a MonadPlus"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::cycle(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - static_assert(N::value >= 0, - "hana::cycle(xs, n) requires 'n' to be non-negative"); - - return Cycle::apply(static_cast<Xs&&>(xs), n); - } - //! @endcond - - namespace detail { - template <typename M, std::size_t n, bool = n % 2 == 0> - struct cycle_helper; - - template <typename M> - struct cycle_helper<M, 0, true> { - template <typename Xs> - static constexpr auto apply(Xs const&) - { return hana::empty<M>(); } - }; - - template <typename M, std::size_t n> - struct cycle_helper<M, n, true> { - template <typename Xs> - static constexpr auto apply(Xs const& xs) - { return cycle_helper<M, n/2>::apply(hana::concat(xs, xs)); } - }; - - template <typename M, std::size_t n> - struct cycle_helper<M, n, false> { - template <typename Xs> - static constexpr auto apply(Xs const& xs) - { return hana::concat(xs, cycle_helper<M, n-1>::apply(xs)); } - }; - } - - template <typename M, bool condition> - struct cycle_impl<M, when<condition>> : default_ { - template <typename Xs, typename N> - static constexpr auto apply(Xs const& xs, N const&) { - constexpr std::size_t n = N::value; - return detail::cycle_helper<M, n>::apply(xs); - } - }; - - namespace detail { - template <std::size_t N, std::size_t Len> - struct cycle_indices { - static constexpr auto compute_value() { - detail::array<std::size_t, N * Len> indices{}; - // Avoid (incorrect) Clang warning about remainder by zero - // in the loop below. - std::size_t len = Len; - for (std::size_t i = 0; i < N * Len; ++i) - indices[i] = i % len; - return indices; - } - - static constexpr auto value = compute_value(); - }; - } - - template <typename S> - struct cycle_impl<S, when<Sequence<S>::value>> { - template <typename Indices, typename Xs, std::size_t ...i> - static constexpr auto cycle_helper(Xs&& xs, std::index_sequence<i...>) { - constexpr auto indices = Indices::value; - (void)indices; // workaround GCC warning when sizeof...(i) == 0 - return hana::make<S>(hana::at_c<indices[i]>(xs)...); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - using Indices = detail::cycle_indices<n, len>; - return cycle_helper<Indices>(static_cast<Xs&&>(xs), - std::make_index_sequence<n * len>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_CYCLE_HPP diff --git a/contrib/restricted/boost/boost/hana/define_struct.hpp b/contrib/restricted/boost/boost/hana/define_struct.hpp deleted file mode 100644 index 04ea728603..0000000000 --- a/contrib/restricted/boost/boost/hana/define_struct.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/*! -@file -Defines the `BOOST_HANA_DEFINE_STRUCT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DEFINE_STRUCT_HPP -#define BOOST_HANA_DEFINE_STRUCT_HPP - -#include <boost/hana/fwd/define_struct.hpp> - -#include <boost/hana/detail/struct_macros.hpp> - -#endif // !BOOST_HANA_DEFINE_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/algorithm.hpp b/contrib/restricted/boost/boost/hana/detail/algorithm.hpp deleted file mode 100644 index 1929847e7a..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/algorithm.hpp +++ /dev/null @@ -1,186 +0,0 @@ -/*! -@file -Defines several `constexpr` algorithms. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_ALGORITHM_HPP -#define BOOST_HANA_DETAIL_ALGORITHM_HPP - -#include <boost/hana/functional/placeholder.hpp> - -#include <boost/hana/config.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - // Do not call this swap, otherwise it can get picked up by ADL and conflict - // with std::swap (see https://github.com/boostorg/hana/issues/297). - template <typename T> - constexpr void constexpr_swap(T& x, T& y) { - auto tmp = x; - x = y; - y = std::move(tmp); - } - - template <typename BidirIter> - constexpr void reverse(BidirIter first, BidirIter last) { - while (first != last) { - if (first == --last) - break; - detail::constexpr_swap(*first, *last); - ++first; - } - } - - template <typename BidirIter, typename BinaryPred> - constexpr bool next_permutation(BidirIter first, BidirIter last, - BinaryPred pred) - { - BidirIter i = last; - if (first == last || first == --i) - return false; - while (true) { - BidirIter ip1 = i; - if (pred(*--i, *ip1)) { - BidirIter j = last; - while (!pred(*i, *--j)) - ; - detail::constexpr_swap(*i, *j); - detail::reverse(ip1, last); - return true; - } - if (i == first) { - detail::reverse(first, last); - return false; - } - } - } - - template <typename BidirIter> - constexpr bool next_permutation(BidirIter first, BidirIter last) - { return detail::next_permutation(first, last, hana::_ < hana::_); } - - - template <typename InputIter1, typename InputIter2, typename BinaryPred> - constexpr bool lexicographical_compare(InputIter1 first1, InputIter1 last1, - InputIter2 first2, InputIter2 last2, - BinaryPred pred) - { - for (; first2 != last2; ++first1, ++first2) { - if (first1 == last1 || pred(*first1, *first2)) - return true; - else if (pred(*first2, *first1)) - return false; - } - return false; - } - - template <typename InputIter1, typename InputIter2> - constexpr bool lexicographical_compare(InputIter1 first1, InputIter1 last1, - InputIter2 first2, InputIter2 last2) - { return detail::lexicographical_compare(first1, last1, first2, last2, hana::_ < hana::_); } - - - template <typename InputIter1, typename InputIter2, typename BinaryPred> - constexpr bool equal(InputIter1 first1, InputIter1 last1, - InputIter2 first2, InputIter2 last2, - BinaryPred pred) - { - for (; first1 != last1 && first2 != last2; ++first1, ++first2) - if (!pred(*first1, *first2)) - return false; - return first1 == last1 && first2 == last2; - } - - template <typename InputIter1, typename InputIter2> - constexpr bool equal(InputIter1 first1, InputIter1 last1, - InputIter2 first2, InputIter2 last2) - { return detail::equal(first1, last1, first2, last2, hana::_ == hana::_); } - - - template <typename BidirIter, typename BinaryPred> - constexpr void sort(BidirIter first, BidirIter last, BinaryPred pred) { - if (first == last) return; - - BidirIter i = first; - for (++i; i != last; ++i) { - BidirIter j = i; - auto t = *j; - for (BidirIter k = i; k != first && pred(t, *--k); --j) - *j = *k; - *j = t; - } - } - - template <typename BidirIter> - constexpr void sort(BidirIter first, BidirIter last) - { detail::sort(first, last, hana::_ < hana::_); } - - - template <typename InputIter, typename T> - constexpr InputIter find(InputIter first, InputIter last, T const& value) { - for (; first != last; ++first) - if (*first == value) - return first; - return last; - } - - template <typename InputIter, typename UnaryPred> - constexpr InputIter find_if(InputIter first, InputIter last, UnaryPred pred) { - for (; first != last; ++first) - if (pred(*first)) - return first; - return last; - } - - template <typename ForwardIter, typename T> - constexpr void iota(ForwardIter first, ForwardIter last, T value) { - while (first != last) { - *first++ = value; - ++value; - } - } - - template <typename InputIt, typename T> - constexpr std::size_t - count(InputIt first, InputIt last, T const& value) { - std::size_t n = 0; - for (; first != last; ++first) - if (*first == value) - ++n; - return n; - } - - template <typename InputIt, typename T, typename F> - constexpr T accumulate(InputIt first, InputIt last, T init, F f) { - for (; first != last; ++first) - init = f(init, *first); - return init; - } - - template <typename InputIt, typename T> - constexpr T accumulate(InputIt first, InputIt last, T init) { - return detail::accumulate(first, last, init, hana::_ + hana::_); - } - - template <typename ForwardIt> - constexpr ForwardIt min_element(ForwardIt first, ForwardIt last) { - if (first == last) - return last; - - ForwardIt smallest = first; - ++first; - for (; first != last; ++first) - if (*first < *smallest) - smallest = first; - return smallest; - } -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_ALGORITHM_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/any_of.hpp b/contrib/restricted/boost/boost/hana/detail/any_of.hpp deleted file mode 100644 index de6b1c6ad2..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/any_of.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::any_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_ANY_OF_HPP -#define BOOST_HANA_DETAIL_ANY_OF_HPP - -#include <boost/hana/config.hpp> - -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - std::false_type expand(...); - - template <template <typename ...> class Predicate, typename ...T> - decltype(expand( - typename std::enable_if<!Predicate<T>::value, void*>::type{}... - )) any_of_impl(int); - - template <template <typename ...> class Predicate, typename ...T> - std::true_type any_of_impl(...); - - //! @ingroup group-details - //! Returns whether the `Predicate` is satisfied by any of the `T...`. - //! - //! This metafunction will short-circuit the evaluation at the first - //! type satisfying the predicate, if such a type exists. - //! - //! - //! @note - //! The implementation technique used here was originally shown to - //! me by Eric Fiselier. All credits where due. - template <template <typename ...> class Predicate, typename ...T> - struct any_of - : decltype(any_of_impl<Predicate, T...>(int{})) - { }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_ANY_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/array.hpp b/contrib/restricted/boost/boost/hana/detail/array.hpp deleted file mode 100644 index 8b2c276f5e..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/array.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::array`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_ARRAY_HPP -#define BOOST_HANA_DETAIL_ARRAY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/functional/placeholder.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename N> - constexpr N factorial(N n) { - N result = 1; - while (n != 0) - result *= n--; - return result; - } - - //! @ingroup group-details - //! A minimal `std::array` with better `constexpr` support. - //! - //! We also provide some algorithms from the `constexpr/algorithm.hpp` - //! header as member functions to make them easier to use in constexpr - //! contexts, since a `constexpr` `array` can't be mutated in place. - template <typename T, std::size_t Size> - struct array { - T elems_[Size > 0 ? Size : 1]; - - constexpr T& operator[](std::size_t n) - { return elems_[n]; } - - constexpr T const& operator[](std::size_t n) const - { return elems_[n]; } - - constexpr std::size_t size() const noexcept - { return Size; } - - constexpr T* begin() noexcept { return elems_; } - constexpr T const* begin() const noexcept { return elems_; } - constexpr T* end() noexcept { return elems_ + Size; } - constexpr T const* end() const noexcept { return elems_ + Size; } - - // Algorithms from constexpr/algorithm.hpp - constexpr array reverse() const { - array result = *this; - detail::reverse(result.begin(), result.end()); - return result; - } - - template <typename BinaryPred> - constexpr auto permutations(BinaryPred pred) const { - array<array<T, Size>, detail::factorial(Size)> result{}; - auto out = result.begin(); - array copy = *this; - - do *out++ = copy; - while (detail::next_permutation(copy.begin(), copy.end(), pred)); - - return result; - } - - constexpr auto permutations() const - { return this->permutations(hana::_ < hana::_); } - - - template <typename BinaryPred> - constexpr auto sort(BinaryPred pred) const { - array result = *this; - detail::sort(result.begin(), result.end(), pred); - return result; - } - - constexpr auto sort() const - { return this->sort(hana::_ < hana::_); } - - template <typename U> - constexpr auto iota(U value) const { - array result = *this; - detail::iota(result.begin(), result.end(), value); - return result; - } - }; - - template <typename T, std::size_t M, typename U, std::size_t N> - constexpr bool operator==(array<T, M> a, array<U, N> b) - { return M == N && detail::equal(a.begin(), a.end(), b.begin(), b.end()); } - - template <typename T, std::size_t M, typename U, std::size_t N> - constexpr bool operator<(array<T, M> a, array<U, N> b) { - return M < N || detail::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); - } - -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_ARRAY_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/canonical_constant.hpp b/contrib/restricted/boost/boost/hana/detail/canonical_constant.hpp deleted file mode 100644 index 07d636fa17..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/canonical_constant.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::CanonicalConstant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP -#define BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @ingroup group-details - //! Tag representing a canonical `Constant`. - //! - //! This is an implementation detail used to provide many models for - //! stuff like `Monoid`, `Group`, etc. To create a `CanonicalConstant`, - //! simply create an object with a nested `hana_tag` equal to the proper - //! specialization of `CanonicalConstant<T>`, and then also provide a - //! `constexpr` static member `::%value` holding the value of the constant. - template <typename T> - struct CanonicalConstant { - using value_type = T; - }; -} BOOST_HANA_NAMESPACE_END - - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/when.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // Constant - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct value_impl<detail::CanonicalConstant<T>> { - template <typename X> - static constexpr decltype(auto) apply() - { return X::value; } - }; - - namespace detail { - template <typename T, typename X> - struct canonical_constant { - static constexpr auto value = hana::to<T>(hana::value<X>()); - using hana_tag = detail::CanonicalConstant<T>; - }; - } - - template <typename T, typename C> - struct to_impl<detail::CanonicalConstant<T>, C, when< - hana::Constant<C>::value && - is_convertible<typename C::value_type, T>::value - >> - : embedding<is_embedded<typename C::value_type, T>::value> - { - template <typename X> - static constexpr detail::canonical_constant<T, X> apply(X const&) - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // IntegralConstant (when value_type is integral) - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct IntegralConstant<detail::CanonicalConstant<T>> { - static constexpr bool value = std::is_integral<T>::value; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_CANONICAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/concepts.hpp b/contrib/restricted/boost/boost/hana/detail/concepts.hpp deleted file mode 100644 index d7b48bc5ec..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/concepts.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Defines concepts from the Standard library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_CONCEPTS_HPP -#define BOOST_HANA_DETAIL_CONCEPTS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/std_common_type.hpp> -#include <boost/hana/detail/void_t.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @cond - ////////////////////////////////////////////////////////////////////////// - // EqualityComparable - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U = T, typename = void> - struct EqualityComparable : std::false_type { }; - - template <typename T> - struct EqualityComparable<T, T, detail::void_t< - decltype(static_cast<T&&>(*(T*)0) == static_cast<T&&>(*(T*)0) ? 0:0), - decltype(static_cast<T&&>(*(T*)0) != static_cast<T&&>(*(T*)0) ? 0:0) - >> : std::true_type { }; - - template <typename T, typename U> - struct EqualityComparable<T, U, typename std::enable_if< - !std::is_same<T, U>::value, detail::void_t< - decltype(static_cast<T&&>(*(T*)0) == static_cast<U&&>(*(U*)0) ? 0:0), - decltype(static_cast<U&&>(*(U*)0) == static_cast<T&&>(*(T*)0) ? 0:0), - decltype(static_cast<T&&>(*(T*)0) != static_cast<U&&>(*(U*)0) ? 0:0), - decltype(static_cast<U&&>(*(U*)0) != static_cast<T&&>(*(T*)0) ? 0:0), - typename detail::std_common_type<T, U>::type - >>::type> : std::integral_constant<bool, - EqualityComparable<T>::value && - EqualityComparable<U>::value && - EqualityComparable<typename detail::std_common_type<T, U>::type>::value - > { }; - - - ////////////////////////////////////////////////////////////////////////// - // LessThanComparable - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U = T, typename = void> - struct LessThanComparable : std::false_type { }; - - template <typename T> - struct LessThanComparable<T, T, detail::void_t< - decltype(static_cast<T&&>(*(T*)0) < static_cast<T&&>(*(T*)0) ? 0:0) - >> : std::true_type { }; - - template <typename T, typename U> - struct LessThanComparable<T, U, std::enable_if_t< - !std::is_same<T, U>::value, - detail::void_t< - decltype(static_cast<T&&>(*(T*)0) < static_cast<U&&>(*(U*)0) ? 0:0), - decltype(static_cast<U&&>(*(U*)0) < static_cast<T&&>(*(T*)0) ? 0:0), - typename detail::std_common_type<T, U>::type - > - >> - : std::integral_constant<bool, - LessThanComparable<T>::value && - LessThanComparable<U>::value && - LessThanComparable<typename detail::std_common_type<T, U>::type>::value - > - { }; - //! @endcond -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_CONCEPTS_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/create.hpp b/contrib/restricted/boost/boost/hana/detail/create.hpp deleted file mode 100644 index 354e5590ca..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/create.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::create`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_CREATE_HPP -#define BOOST_HANA_DETAIL_CREATE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @ingroup group-details - //! Implementation of the generic `std::make_xxx` pattern for arbitrary - //! `xxx`s. - template <template <typename ...> class T> - struct create { - template <typename ...X> - constexpr T<typename detail::decay<X>::type...> - operator()(X&& ...x) const { - return T<typename detail::decay<X>::type...>{ - static_cast<X&&>(x)... - }; - } - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_CREATE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/decay.hpp b/contrib/restricted/boost/boost/hana/detail/decay.hpp deleted file mode 100644 index 7d8affa0b2..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/decay.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines a replacement for `std::decay`, which is sometimes too slow at -compile-time. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_DECAY_HPP -#define BOOST_HANA_DETAIL_DECAY_HPP - -#include <boost/hana/config.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @ingroup group-details - //! Equivalent to `std::decay`, except faster. - //! - //! `std::decay` in libc++ is implemented in a suboptimal way. Since - //! this is used literally everywhere by the `make<...>` functions, it - //! is very important to keep this as efficient as possible. - //! - //! @note - //! `std::decay` is still being used in some places in the library. - //! Indeed, this is a peephole optimization and it would not be wise - //! to clutter the code with our own implementation of `std::decay`, - //! except when this actually makes a difference in compile-times. - template <typename T, typename U = typename std::remove_reference<T>::type> - struct decay { - using type = typename std::remove_cv<U>::type; - }; - - template <typename T, typename U> - struct decay<T, U[]> { using type = U*; }; - template <typename T, typename U, std::size_t N> - struct decay<T, U[N]> { using type = U*; }; - - template <typename T, typename R, typename ...A> - struct decay<T, R(A...)> { using type = R(*)(A...); }; - template <typename T, typename R, typename ...A> - struct decay<T, R(A..., ...)> { using type = R(*)(A..., ...); }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_DECAY_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/dispatch_if.hpp b/contrib/restricted/boost/boost/hana/detail/dispatch_if.hpp deleted file mode 100644 index 6e95f58878..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/dispatch_if.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Defines `BOOST_HANA_DISPATCH_IF`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_DISPATCH_IF_HPP -#define BOOST_HANA_DETAIL_DISPATCH_IF_HPP - -#include <boost/hana/config.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - struct deleted_implementation { - template <typename ...T> - static constexpr auto apply(T&& ...) = delete; - }; - - //! @ingroup group-details - //! Dispatch to the given implementation method only when a condition is - //! satisfied. - //! - //! If the condition is satisfied, this macro is equivalent to the type - //! `IMPL`. Otherwise, it is equivalent to a type with a deleted static - //! function named `apply`. When a tag-dispatching error happens, the - //! condition should be false and the deleted static function `apply` - //! will prevent the compiler from generating too much garbage. - //! - //! @note - //! When `BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS` is defined, the - //! condition is always ignored and this macro expands to the - //! implementation only. - //! - //! @remark - //! This must be implemented as a macro, because we don't want the - //! condition to be evaluated at all when - //! `BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS` is defined. -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - #define BOOST_HANA_DISPATCH_IF(IMPL, ...) \ - ::std::conditional_t< \ - (__VA_ARGS__), \ - IMPL, \ - ::boost::hana::deleted_implementation \ - > \ - /**/ -#else - #define BOOST_HANA_DISPATCH_IF(IMPL, ...) IMPL -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_DISPATCH_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/ebo.hpp b/contrib/restricted/boost/boost/hana/detail/ebo.hpp deleted file mode 100644 index 01ca009ce2..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/ebo.hpp +++ /dev/null @@ -1,115 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::ebo`. - -@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) - */ - -#ifndef BOOST_HANA_DETAIL_EBO_HPP -#define BOOST_HANA_DETAIL_EBO_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/intrinsics.hpp> - - -namespace _hana { - ////////////////////////////////////////////////////////////////////////// - // ebo<K, V> - // - // Building block to implement the Empty Base Optimization (EBO). We - // use a short name and define it in a short namespace to reduce - // symbol lengths, since this type is used as a building block for - // other widely used types such as `hana::pair`. - // - // When available, we use compiler intrinsics to reduce the number - // of instantiations. - // - // `ebo` provides a limited set of constructors to reduce instantiations. - // Also, the constructors are open-ended and they do not check for the - // validity of their arguments, again to reduce compile-time costs. - // Users of `ebo` should make sure that they only try to construct an - // `ebo` from a compatible value. - // - // EBOs can be indexed using an arbitrary type. The recommended usage is - // to define an integrap constant wrapper for the specific container using - // EBO, and then index using that wrapper: - // - // template <int> struct idx; // wrapper for tuple - // template <typename ...T> - // struct tuple : ebo<idx<0>, T0>, ebo<idx<1>, T1>, ... { }; - // - // The reason for defining one wrapper per container is to avoid any issues - // that can arise when using `ebo_get`, which casts to the base class. If - // `tuple` and `pair` are inheritting from `ebo`s with the same indexing - // scheme, trying to use `ebo_get` on a tuple of pairs will trigger an - // ambiguous base class conversion, since both tuple and pair inherit - // from `ebo`s with the same keys. - ////////////////////////////////////////////////////////////////////////// - template <typename K, typename V, bool = - BOOST_HANA_TT_IS_EMPTY(V) && !BOOST_HANA_TT_IS_FINAL(V) - > - struct ebo; - - // Specialize storage for empty types - template <typename K, typename V> - struct ebo<K, V, true> : V { - constexpr ebo() { } - - template <typename T> - explicit constexpr ebo(T&& t) - : V(static_cast<T&&>(t)) - { } - }; - - // Specialize storage for non-empty types - template <typename K, typename V> - struct ebo<K, V, false> { - constexpr ebo() : data_() { } - - template <typename T> - explicit constexpr ebo(T&& t) - : data_(static_cast<T&&>(t)) - { } - - V data_; - }; - - ////////////////////////////////////////////////////////////////////////// - // ebo_get - ////////////////////////////////////////////////////////////////////////// - template <typename K, typename V> - constexpr V const& ebo_get(ebo<K, V, true> const& x) - { return x; } - - template <typename K, typename V> - constexpr V& ebo_get(ebo<K, V, true>& x) - { return x; } - - template <typename K, typename V> - constexpr V&& ebo_get(ebo<K, V, true>&& x) - { return static_cast<V&&>(x); } - - - template <typename K, typename V> - constexpr V const& ebo_get(ebo<K, V, false> const& x) - { return x.data_; } - - template <typename K, typename V> - constexpr V& ebo_get(ebo<K, V, false>& x) - { return x.data_; } - - template <typename K, typename V> - constexpr V&& ebo_get(ebo<K, V, false>&& x) - { return static_cast<V&&>(x.data_); } -} // end namespace _hana - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - using ::_hana::ebo; - using ::_hana::ebo_get; - } -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_EBO_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/fast_and.hpp b/contrib/restricted/boost/boost/hana/detail/fast_and.hpp deleted file mode 100644 index ebd0389df3..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/fast_and.hpp +++ /dev/null @@ -1,29 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::fast_and`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_FAST_AND_HPP -#define BOOST_HANA_DETAIL_FAST_AND_HPP - -#include <boost/hana/config.hpp> - -#include <type_traits> - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunused-value" - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <bool ...b> - struct fast_and - : std::is_same<fast_and<b...>, fast_and<(b, true)...>> - { }; -} BOOST_HANA_NAMESPACE_END - -#pragma clang diagnostic pop - -#endif // !BOOST_HANA_DETAIL_FAST_AND_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/first_unsatisfied_index.hpp b/contrib/restricted/boost/boost/hana/detail/first_unsatisfied_index.hpp deleted file mode 100644 index e42cc598e5..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/first_unsatisfied_index.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::first_unsatisfied_index`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP -#define BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/value.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <bool, typename Pred, typename ...Xs> - struct find_tail_size; - - template <typename Pred, typename X, typename ...Xs> - struct find_tail_size<true, Pred, X, Xs...> { - static constexpr int value = find_tail_size< - static_cast<bool>(hana::value<decltype(std::declval<Pred>()(std::declval<X>()))>()), - Pred, Xs... - >::value; - }; - - template <typename Pred> - struct find_tail_size<true, Pred> { - static constexpr int value = -1; - }; - - template <typename Pred, typename ...Xs> - struct find_tail_size<false, Pred, Xs...> { - static constexpr int value = sizeof...(Xs); - }; - - //! @ingroup group-details - //! Returns the index of the first element which does not satisfy `Pred`, - //! or `sizeof...(Xs)` if no such element exists. - template <typename Pred> - struct first_unsatisfied_index { - template <typename ...Xs> - constexpr auto operator()(Xs&& ...) const { - return hana::size_c< - sizeof...(Xs) - 1 - find_tail_size<true, Pred, Xs&&...>::value - >; - } - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_FIRST_UNSATISFIED_INDEX_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/has_common_embedding.hpp b/contrib/restricted/boost/boost/hana/detail/has_common_embedding.hpp deleted file mode 100644 index ffaf6908b8..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/has_common_embedding.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::has_[nontrivial_]common_embedding`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP -#define BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/detail/void_t.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <template <typename...> class Concept, typename T, typename U, typename = void> - struct has_common_embedding_impl : std::false_type { }; - - template <template <typename...> class Concept, typename T, typename U> - struct has_common_embedding_impl<Concept, T, U, detail::void_t< - typename common<T, U>::type - >> { - using Common = typename common<T, U>::type; - using type = std::integral_constant<bool, - Concept<T>::value && - Concept<U>::value && - Concept<Common>::value && - is_embedded<T, Common>::value && - is_embedded<U, Common>::value - >; - }; - - //! @ingroup group-details - //! Returns whether `T` and `U` both have an embedding into a - //! common type. - //! - //! If `T` and `U` do not have a common-type, this metafunction returns - //! false. - template <template <typename...> class Concept, typename T, typename U> - using has_common_embedding = typename has_common_embedding_impl<Concept, T, U>::type; - - template <template <typename...> class Concept, typename T, typename U> - struct has_nontrivial_common_embedding_impl - : has_common_embedding_impl<Concept, T, U> - { }; - - template <template <typename...> class Concept, typename T> - struct has_nontrivial_common_embedding_impl<Concept, T, T> - : std::false_type - { }; - - //! @ingroup group-details - //! Returns whether `T` and `U` are distinct and both have an embedding - //! into a common type. - //! - //! If `T` and `U` do not have a common-type, this metafunction returns - //! false. - template <template <typename...> class Concept, typename T, typename U> - using has_nontrivial_common_embedding = - typename has_nontrivial_common_embedding_impl<Concept, T, U>::type; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_HAS_COMMON_EMBEDDING_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/has_duplicates.hpp b/contrib/restricted/boost/boost/hana/detail/has_duplicates.hpp deleted file mode 100644 index ff9f080482..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/has_duplicates.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::has_duplicates`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP -#define BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/equal.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename T, typename ...U> - constexpr std::size_t pack_count() { - std::size_t c = 0; - std::size_t expand[] = {0, // avoid empty array - (decltype(hana::equal(std::declval<T>(), std::declval<U>()))::value - ? ++c - : c)... - }; - (void)expand; - - return c; - } - - //! @ingroup group-details - //! Returns whether any of the `T`s are duplicate w.r.t. `hana::equal`. - //! - //! In particular, this does not check whether all of the `T`s are unique - //! as _types_, but rather whether they are unique when compared as - //! `hana::equal(std::declval<T>(), std::declval<U>())`. This assumes - //! the comparison to return an `IntegralConstant` that can be explicitly - //! converted to `bool`. - //! - //! @note - //! Since this utility is mostly used in assertions to check that there - //! are no duplicates in a sequence, we expect it to return `false` most - //! of the time (otherwise we will assert). Hence, this implementation is - //! biased towards the fact that we __will__ have to compare every pair of - //! elements in most cases, and it does not try to be lazy. - //! - //! @todo - //! This implementation is O(n^2). We could do it in O(n), but that would - //! require a more elaborate setup including storage with O(1) lookup - //! (which could be based on a compile-time hash). If we implement such - //! storage for associative sequences, we could use it to optimize this. - template <typename ...T> - struct has_duplicates { - static constexpr bool value = - sizeof...(T) > 0 && - !detail::fast_and<(detail::pack_count<T, T...>() == 1)...>::value - ; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_HAS_DUPLICATES_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/hash_table.hpp b/contrib/restricted/boost/boost/hana/detail/hash_table.hpp deleted file mode 100644 index 19a85dd764..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/hash_table.hpp +++ /dev/null @@ -1,145 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::hash_table`. - -@copyright Louis Dionne 2016 -@copyright Jason Rice 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) - */ - -#ifndef BOOST_HANA_DETAIL_HASH_TABLE_HPP -#define BOOST_HANA_DETAIL_HASH_TABLE_HPP - -#include <boost/hana/equal.hpp> -#include <boost/hana/ext/std/integer_sequence.hpp> -#include <boost/hana/ext/std/integral_constant.hpp> -#include <boost/hana/find_if.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/hash.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/range.hpp> -#include <boost/hana/type.hpp> -#include <boost/hana/value.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Hash, std::size_t ...i> - struct bucket { }; - - template <typename ...Buckets> - struct hash_table - : Buckets... - { }; - - // find_indices: - // Returns an `index_sequence` containing possible indices for the given - // `Key` in the `Map`. - template <typename Hash, std::size_t ...i> - std::index_sequence<i...> find_indices_impl(bucket<Hash, i...> const&); - - template <typename Hash> - std::index_sequence<> find_indices_impl(...); - - template <typename Map, typename Key> - struct find_indices { - using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; - using type = decltype(detail::find_indices_impl<Hash>(std::declval<Map>())); - }; - // end find_indices - - // find_index: - // Returns the actual index of a `Key` in the `Map`. The type of the key - // associated to any given index must be retrievable with the `KeyAtIndex` - // alias. - template <template <std::size_t> class KeyAtIndex, typename Key> - struct find_pred { - template <typename Index> - auto operator()(Index const&) const -> decltype( - hana::equal(std::declval<KeyAtIndex<Index::value>>(), - std::declval<Key>()) - ); - }; - - template <typename Indices, typename Key, template <std::size_t> class KeyAtIndex> - struct find_index_impl { - using type = decltype(hana::find_if(Indices{}, find_pred<KeyAtIndex, Key>{})); - }; - - // This is a peephole optimization for buckets that have a single entry. - // It provides a nice speedup in the at_key.number_of_lookups benchmark. - // It is perhaps possible to make this part of `find_if` itself, but we - // should make sure that we retain that speedup. - template <std::size_t i, typename Key, template <std::size_t> class KeyAtIndex> - struct find_index_impl<std::index_sequence<i>, Key, KeyAtIndex> { - using Equal = decltype( - hana::equal(std::declval<KeyAtIndex<i>>(), - std::declval<Key>()) - ); - using type = typename std::conditional<Equal::value, - hana::optional<std::integral_constant<std::size_t, i>>, - hana::optional<> - >::type; - }; - - template <typename Map, typename Key, template <std::size_t> class KeyAtIndex> - struct find_index { - using Indices = typename find_indices<Map, Key>::type; - using type = typename find_index_impl<Indices, Key, KeyAtIndex>::type; - }; - // end find_index - - // bucket_insert: - // Inserts the given `Index` into the bucket of the `Map` in which `Key` falls. - template <typename Bucket, typename Hash, std::size_t Index> - struct update_bucket { - using type = Bucket; - }; - - template <std::size_t ...i, typename Hash, std::size_t Index> - struct update_bucket<bucket<Hash, i...>, Hash, Index> { - using type = bucket<Hash, i..., Index>; - }; - - template <typename Map, typename Key, std::size_t Index, bool = - (find_indices<Map, Key>::type::size() > 0) - > - struct bucket_insert; - - template <typename ...Buckets, typename Key, std::size_t Index> - struct bucket_insert<hash_table<Buckets...>, Key, Index, true> { - // There is a bucket for that Hash; append the new index to it. - using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; - using type = hash_table<typename update_bucket<Buckets, Hash, Index>::type...>; - }; - - template <typename ...Buckets, typename Key, std::size_t Index> - struct bucket_insert<hash_table<Buckets...>, Key, Index, false> { - // There is no bucket for that Hash; insert a new bucket. - using Hash = typename decltype(hana::hash(std::declval<Key>()))::type; - using type = hash_table<Buckets..., bucket<Hash, Index>>; - }; - // end bucket_insert - - // make_hash_table: - // Creates a `hash_table` type able of holding the given number of - // elements. The type of the key associated to any given index must - // be retrievable using the `KeyAtIndex` alias. All the keys must - // be distinct and have different hashes too. - template <template <std::size_t> class KeyAtIndex, std::size_t N, - typename Indices = std::make_index_sequence<N>> - struct make_hash_table; - - template <template <std::size_t> class KeyAtIndex, std::size_t N, std::size_t ...i> - struct make_hash_table<KeyAtIndex, N, std::index_sequence<i...>> { - using type = hash_table< - bucket<typename decltype(hana::hash(std::declval<KeyAtIndex<i>>()))::type, i>... - >; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_HASH_TABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/index_if.hpp b/contrib/restricted/boost/boost/hana/detail/index_if.hpp deleted file mode 100644 index f643eb76ff..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/index_if.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::index_if`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_INDEX_IF_HPP -#define BOOST_HANA_DETAIL_INDEX_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/optional.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <std::size_t i, std::size_t N, bool Done> - struct index_if_helper; - - template <std::size_t i, std::size_t N> - struct index_if_helper<i, N, false> { - template <typename Pred, typename X1, typename ...Xs> - using f = typename index_if_helper<i + 1, N, - static_cast<bool>(detail::decay<decltype( - std::declval<Pred>()(std::declval<X1>()))>::type::value) - >::template f<Pred, Xs...>; - }; - - template <std::size_t N> - struct index_if_helper<N, N, false> { - template <typename ...> - using f = hana::optional<>; - }; - - template <std::size_t i, std::size_t N> - struct index_if_helper<i, N, true> { - template <typename ...> - using f = hana::optional<hana::size_t<i - 1>>; - }; - - template <typename Pred, typename ...Xs> - struct index_if { - using type = typename index_if_helper<0, sizeof...(Xs), false> - ::template f<Pred, Xs...>; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_INDEX_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/integral_constant.hpp b/contrib/restricted/boost/boost/hana/detail/integral_constant.hpp deleted file mode 100644 index 6fa7735164..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/integral_constant.hpp +++ /dev/null @@ -1,245 +0,0 @@ -/*! -@file -Defines the barebones `boost::hana::integral_constant` template, but no -operations on it. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/operators/adl.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Tag representing `hana::integral_constant`. - //! @relates hana::integral_constant - template <typename T> - struct integral_constant_tag { - using value_type = T; - }; - - namespace ic_detail { - template <typename T, T v> - struct with_index_t { - template <typename F> - constexpr void operator()(F&& f) const; - }; - - template <typename T, T v> - struct times_t { - static constexpr with_index_t<T, v> with_index{}; - - template <typename F> - constexpr void operator()(F&& f) const; - }; - } - - //! @ingroup group-datatypes - //! Compile-time value of an integral type. - //! - //! An `integral_constant` is an object that represents a compile-time - //! integral value. As the name suggests, `hana::integral_constant` is - //! basically equivalent to `std::integral_constant`, except that - //! `hana::integral_constant` also provide other goodies to make them - //! easier to use, like arithmetic operators and similar features. In - //! particular, `hana::integral_constant` is guaranteed to inherit from - //! the corresponding `std::integral_constant`, and hence have the same - //! members and capabilities. The sections below explain the extensions - //! to `std::integral_constant` provided by `hana::integral_constant`. - //! - //! - //! Arithmetic operators - //! -------------------- - //! `hana::integral_constant` provides arithmetic operators that return - //! `hana::integral_constant`s to ease writing compile-time arithmetic: - //! @snippet example/integral_constant.cpp operators - //! - //! It is pretty important to realize that these operators return other - //! `integral_constant`s, not normal values of an integral type. - //! Actually, all those operators work pretty much in the same way. - //! Simply put, for an operator `@`, - //! @code - //! integral_constant<T, x>{} @ integral_constant<T, y>{} == integral_constant<T, x @ y>{} - //! @endcode - //! - //! The fact that the operators return `Constant`s is very important - //! because it allows all the information that's known at compile-time - //! to be conserved as long as it's only used with other values known at - //! compile-time. It is also interesting to observe that whenever an - //! `integral_constant` is combined with a normal runtime value, the - //! result will be a runtime value (because of the implicit conversion). - //! In general, this gives us the following table - //! - //! left operand | right operand | result - //! :-----------------: | :-----------------: | :-----------------: - //! `integral_constant` | `integral_constant` | `integral_constant` - //! `integral_constant` | runtime | runtime - //! runtime | `integral_constant` | runtime - //! runtime | runtime | runtime - //! - //! The full range of provided operators is - //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`, unary `-` - //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>` - //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` - //! - %Logical: `||`, `&&`, `!` - //! - //! - //! Construction with user-defined literals - //! --------------------------------------- - //! `integral_constant`s of type `long long` can be created with the - //! `_c` user-defined literal, which is contained in the `literals` - //! namespace: - //! @snippet example/integral_constant.cpp literals - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Constant` and `IntegralConstant`\n - //! An `integral_constant` is a model of the `IntegralConstant` concept in - //! the most obvious way possible. Specifically, - //! @code - //! integral_constant<T, v>::value == v // of type T - //! @endcode - //! The model of `Constant` follows naturally from the model of `IntegralConstant`, i.e. - //! @code - //! value<integral_constant<T, v>>() == v // of type T - //! @endcode - //! - //! 2. `Comparable`, `Orderable`, `Logical`, `Monoid`, `Group`, `Ring`, and `EuclideanRing`, `Hashable`\n - //! Those models are exactly those provided for `Constant`s, which are - //! documented in their respective concepts. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, T v> - struct integral_constant { - //! Call a function n times. - //! - //! `times` allows a nullary function to be invoked `n` times: - //! @code - //! int_<3>::times(f) - //! @endcode - //! should be expanded by any decent compiler to - //! @code - //! f(); f(); f(); - //! @endcode - //! - //! This can be useful in several contexts, e.g. for loop unrolling: - //! @snippet example/integral_constant.cpp times_loop_unrolling - //! - //! Note that `times` is really a static function object, not just a - //! static function. This allows `int_<n>::%times` to be passed to - //! higher-order algorithms: - //! @snippet example/integral_constant.cpp times_higher_order - //! - //! Also, since static members can be accessed using both the `.` and - //! the `::` syntax, one can take advantage of this (loophole?) to - //! call `times` on objects just as well as on types: - //! @snippet example/integral_constant.cpp from_object - //! - //! @note - //! `times` is equivalent to the `hana::repeat` function, which works - //! on an arbitrary `IntegralConstant`. - //! - //! Sometimes, it is also useful to know the index we're at inside the - //! function. This can be achieved by using `times.with_index`: - //! @snippet example/integral_constant.cpp times_with_index_runtime - //! - //! Remember that `times` is a _function object_, and hence it can - //! have subobjects. `with_index` is just a function object nested - //! inside `times`, which allows for this nice little interface. Also - //! note that the indices passed to the function are `integral_constant`s; - //! they are known at compile-time. Hence, we can do compile-time stuff - //! with them, like indexing inside a tuple: - //! @snippet example/integral_constant.cpp times_with_index_compile_time - //! - //! @note - //! `times.with_index(f)` guarantees that the calls to `f` will be - //! done in order of ascending index. In other words, `f` will be - //! called as `f(0)`, `f(1)`, `f(2)`, etc., but with `integral_constant`s - //! instead of normal integers. Side effects can also be done in the - //! function passed to `times` and `times.with_index`. - template <typename F> - static constexpr void times(F&& f) { - f(); f(); ... f(); // n times total - } - - //! Equivalent to `hana::plus` - template <typename X, typename Y> - friend constexpr auto operator+(X&& x, Y&& y); - - //! Equivalent to `hana::minus` - template <typename X, typename Y> - friend constexpr auto operator-(X&& x, Y&& y); - - //! Equivalent to `hana::negate` - template <typename X> - friend constexpr auto operator-(X&& x); - - //! Equivalent to `hana::mult` - template <typename X, typename Y> - friend constexpr auto operator*(X&& x, Y&& y); - - //! Equivalent to `hana::div` - template <typename X, typename Y> - friend constexpr auto operator/(X&& x, Y&& y); - - //! Equivalent to `hana::mod` - template <typename X, typename Y> - friend constexpr auto operator%(X&& x, Y&& y); - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::or_` - template <typename X, typename Y> - friend constexpr auto operator||(X&& x, Y&& y); - - //! Equivalent to `hana::and_` - template <typename X, typename Y> - friend constexpr auto operator&&(X&& x, Y&& y); - - //! Equivalent to `hana::not_` - template <typename X> - friend constexpr auto operator!(X&& x); - - //! Equivalent to `hana::less` - template <typename X, typename Y> - friend constexpr auto operator<(X&& x, Y&& y); - - //! Equivalent to `hana::greater` - template <typename X, typename Y> - friend constexpr auto operator>(X&& x, Y&& y); - - //! Equivalent to `hana::less_equal` - template <typename X, typename Y> - friend constexpr auto operator<=(X&& x, Y&& y); - - //! Equivalent to `hana::greater_equal` - template <typename X, typename Y> - friend constexpr auto operator>=(X&& x, Y&& y); - }; -#else - template <typename T, T v> - struct integral_constant - : std::integral_constant<T, v> - , detail::operators::adl<integral_constant<T, v>> - { - using type = integral_constant; // override std::integral_constant::type - static constexpr ic_detail::times_t<T, v> times{}; - using hana_tag = integral_constant_tag<T>; - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/intrinsics.hpp b/contrib/restricted/boost/boost/hana/detail/intrinsics.hpp deleted file mode 100644 index b3d98654cd..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/intrinsics.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*! -@file -Defines macros for commonly used type traits. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_INTRINSICS_HPP -#define BOOST_HANA_DETAIL_INTRINSICS_HPP - -#include <boost/hana/config.hpp> - - -// We use intrinsics if they are available because it speeds up the -// compile-times. -#if defined(BOOST_HANA_CONFIG_CLANG) -# if __has_extension(is_empty) -# define BOOST_HANA_TT_IS_EMPTY(T) __is_empty(T) -# endif - -# if __has_extension(is_final) -# define BOOST_HANA_TT_IS_FINAL(T) __is_final(T) -# endif - -// TODO: Right now, this intrinsic is never used directly because of -// https://llvm.org/bugs/show_bug.cgi?id=24173 -# if __has_extension(is_constructible) && false -# define BOOST_HANA_TT_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__) -# endif - -# if __has_extension(is_assignable) -# define BOOST_HANA_TT_IS_ASSIGNABLE(T, U) __is_assignable(T, U) -# endif - -# if __has_extension(is_convertible) -# define BOOST_HANA_TT_IS_CONVERTIBLE(T, U) __is_convertible(T, U) -# endif -#endif - -#if !defined(BOOST_HANA_TT_IS_EMPTY) -# include <type_traits> -# define BOOST_HANA_TT_IS_EMPTY(T) ::std::is_empty<T>::value -#endif - -#if !defined(BOOST_HANA_TT_IS_FINAL) -# include <type_traits> -# define BOOST_HANA_TT_IS_FINAL(T) ::std::is_final<T>::value -#endif - -#if !defined(BOOST_HANA_TT_IS_CONSTRUCTIBLE) -# include <type_traits> -# define BOOST_HANA_TT_IS_CONSTRUCTIBLE(...) ::std::is_constructible<__VA_ARGS__>::value -#endif - -#if !defined(BOOST_HANA_TT_IS_ASSIGNABLE) -# include <type_traits> -# define BOOST_HANA_TT_IS_ASSIGNABLE(T, U) ::std::is_assignable<T, U>::value -#endif - -#if !defined(BOOST_HANA_TT_IS_CONVERTIBLE) -# include <type_traits> -# define BOOST_HANA_TT_IS_CONVERTIBLE(T, U) ::std::is_convertible<T, U>::value -#endif - -#endif // !BOOST_HANA_DETAIL_INTRINSICS_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_by.hpp b/contrib/restricted/boost/boost/hana/detail/nested_by.hpp deleted file mode 100644 index 6bdfe70c43..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_by.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::nested_by`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_BY_HPP -#define BOOST_HANA_DETAIL_NESTED_BY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - -#include <boost/hana/functional/flip.hpp> -#include <boost/hana/functional/partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @cond - template <typename Algorithm> - template <typename Predicate, typename Object> - constexpr decltype(auto) nested_by_t<Algorithm>:: - operator()(Predicate&& predicate, Object&& object) const { - return Algorithm{}(static_cast<Object&&>(object), - static_cast<Predicate&&>(predicate)); - } - - template <typename Algorithm> - template <typename Predicate> - constexpr decltype(auto) - nested_by_t<Algorithm>::operator()(Predicate&& predicate) const { - return hana::partial(hana::flip(Algorithm{}), - static_cast<Predicate&&>(predicate)); - } - //! @endcond -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_BY_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_by_fwd.hpp b/contrib/restricted/boost/boost/hana/detail/nested_by_fwd.hpp deleted file mode 100644 index 4e82f64cd6..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_by_fwd.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Forward declares `boost::hana::detail::nested_by`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP -#define BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Algorithm> - struct nested_by_t { - template <typename Predicate, typename Object> - constexpr decltype(auto) - operator()(Predicate&& predicate, Object&& object) const; - - template <typename Predicate> - constexpr decltype(auto) operator()(Predicate&& predicate) const; - }; - - //! @ingroup group-details - //! Provides a `.by` static constexpr function object. - //! - //! When creating a binary function object of type `Algorithm` whose - //! signature is `Object x Predicate -> Return`, `nested_by<Algorithm>` - //! can be used as a base class to `Algorithm`. Doing so will provide a - //! static constexpr member called `by`, which has the two following - //! signatures: - //! @code - //! Predicate x Object -> Return - //! Predicate -> (Object -> Return) - //! @endcode - //! - //! In other words, `nested_by` is a `curry`ed and `flip`ped version of - //! `Algorithm`. Note that the function object `Algorithm` must be - //! default-constructible, since the algorithm will be called as - //! `Algorithm{}(arguments...)`. - //! - //! @note - //! This function object is especially useful because it takes care of - //! avoiding ODR violations caused by the nested static constexpr member. - template <typename Algorithm> - struct nested_by { static constexpr nested_by_t<Algorithm> by{}; }; - - template <typename Algorithm> - constexpr nested_by_t<Algorithm> nested_by<Algorithm>::by; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_BY_FWD_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_than.hpp b/contrib/restricted/boost/boost/hana/detail/nested_than.hpp deleted file mode 100644 index d4a7c5ffc6..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_than.hpp +++ /dev/null @@ -1,29 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::nested_than`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_THAN_HPP -#define BOOST_HANA_DETAIL_NESTED_THAN_HPP - -#include <boost/hana/detail/nested_than_fwd.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/functional/flip.hpp> -#include <boost/hana/functional/partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @cond - template <typename Algorithm> - template <typename X> - constexpr decltype(auto) nested_than_t<Algorithm>::operator()(X&& x) const - { return hana::partial(hana::flip(Algorithm{}), static_cast<X&&>(x)); } - //! @endcond -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_THAN_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_than_fwd.hpp b/contrib/restricted/boost/boost/hana/detail/nested_than_fwd.hpp deleted file mode 100644 index 39231050f3..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_than_fwd.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Forward declares `boost::hana::detail::nested_than`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP -#define BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Algorithm> - struct nested_than_t { - template <typename X> - constexpr decltype(auto) operator()(X&& x) const; - }; - - //! @ingroup group-details - //! Provides a `.than` static constexpr function object. - //! - //! When creating a binary function object of type `Algo` whose signature - //! is `A x B -> Return`, `nested_than<Algo>` can be used as a base class - //! of `Algo`. Doing so will provide a static constexpr member called - //! `than`, which has the following signature: - //! @code - //! B -> A -> Return - //! @endcode - //! - //! Note that the function object `Algo` must be default-constructible, - //! since it will be called as `Algo{}(arguments...)`. - //! - //! @note - //! This function object is especially useful because it takes care of - //! avoiding ODR violations caused by the nested static constexpr member. - template <typename Algorithm> - struct nested_than { static constexpr nested_than_t<Algorithm> than{}; }; - - template <typename Algorithm> - constexpr nested_than_t<Algorithm> nested_than<Algorithm>::than; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_THAN_FWD_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_to.hpp b/contrib/restricted/boost/boost/hana/detail/nested_to.hpp deleted file mode 100644 index 2f6154d367..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_to.hpp +++ /dev/null @@ -1,28 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::nested_to`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_TO_HPP -#define BOOST_HANA_DETAIL_NESTED_TO_HPP - -#include <boost/hana/detail/nested_to_fwd.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/functional/partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @cond - template <typename Algorithm> - template <typename X> - constexpr decltype(auto) nested_to_t<Algorithm>::operator()(X&& x) const - { return hana::partial(Algorithm{}, static_cast<X&&>(x)); } - //! @endcond -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_TO_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/nested_to_fwd.hpp b/contrib/restricted/boost/boost/hana/detail/nested_to_fwd.hpp deleted file mode 100644 index ec3161136c..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/nested_to_fwd.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Forward declares `boost::hana::detail::nested_to`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP -#define BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Algorithm> - struct nested_to_t { - template <typename X> - constexpr decltype(auto) operator()(X&& x) const; - }; - - //! @ingroup group-details - //! Provides a `.to` static constexpr function object. - //! - //! When creating a binary function object of type `Algo` whose signature - //! is `Object x Object -> Return`, `nested_to<Algo>` can be used as a base - //! class of `Algo`. Doing so will provide a static constexpr member called - //! `to`, which has the following signature: - //! @code - //! Object -> Object -> Return - //! @endcode - //! - //! Note that the function object `Algo` must be default-constructible, - //! since the algorithm will be called as `Algo{}(arguments...)`. - //! - //! @note - //! This function object is especially useful because it takes care of - //! avoiding ODR violations caused by the nested static constexpr member. - template <typename Algorithm> - struct nested_to { static constexpr nested_to_t<Algorithm> to{}; }; - - template <typename Algorithm> - constexpr nested_to_t<Algorithm> nested_to<Algorithm>::to; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_NESTED_TO_FWD_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/adl.hpp b/contrib/restricted/boost/boost/hana/detail/operators/adl.hpp deleted file mode 100644 index 59a81600b6..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/adl.hpp +++ /dev/null @@ -1,34 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::operators::adl`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_ADL_HPP -#define BOOST_HANA_DETAIL_OPERATORS_ADL_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace operators { - //! @ingroup group-details - //! Enables [ADL](http://en.cppreference.com/w/cpp/language/adl) in the - //! `hana::detail::operators` namespace. - //! - //! This is used by containers in Hana as a quick way to automatically - //! define the operators associated to some concepts, in conjunction - //! with the `detail::xxx_operators` family of metafunctions. - //! - //! Note that `adl` can be passed template arguments to make it unique - //! amongst a set of derived classes. This allows a set of derived classes - //! not to possess a common base class, which would disable the EBO when - //! many of these derived classes are stored in a Hana container. If EBO - //! is not a concern, `adl<>` can simply be used. - template <typename ...> - struct adl { }; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_ADL_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/arithmetic.hpp b/contrib/restricted/boost/boost/hana/detail/operators/arithmetic.hpp deleted file mode 100644 index 58f432db78..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/arithmetic.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Defines arithmetic operators. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP -#define BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/fwd/div.hpp> -#include <boost/hana/fwd/minus.hpp> -#include <boost/hana/fwd/mod.hpp> -#include <boost/hana/fwd/mult.hpp> -#include <boost/hana/fwd/negate.hpp> -#include <boost/hana/fwd/plus.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Tag> - struct arithmetic_operators { - static constexpr bool value = false; - }; - - namespace operators { - template <typename X, typename Y, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || - detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator+(X&& x, Y&& y) - { return hana::plus(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - - template <typename X, typename Y, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || - detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator-(X&& x, Y&& y) - { return hana::minus(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value - >::type> - constexpr auto operator-(X&& x) - { return hana::negate(static_cast<X&&>(x)); } - - - template <typename X, typename Y, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || - detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator*(X&& x, Y&& y) - { return hana::mult(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - - template <typename X, typename Y, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || - detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator/(X&& x, Y&& y) - { return hana::div(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::arithmetic_operators<typename hana::tag_of<X>::type>::value || - detail::arithmetic_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator%(X&& x, Y&& y) - { return hana::mod(static_cast<X&&>(x), static_cast<Y&&>(y)); } - } // end namespace operators -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_ARITHMETIC_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/comparable.hpp b/contrib/restricted/boost/boost/hana/detail/operators/comparable.hpp deleted file mode 100644 index 0c110fe3a3..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/comparable.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*! -@file -Defines operators for Comparables. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP -#define BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/not_equal.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Tag> - struct comparable_operators { - static constexpr bool value = false; - }; - - namespace operators { - template <typename X, typename Y, typename = typename std::enable_if< - detail::comparable_operators<typename hana::tag_of<X>::type>::value || - detail::comparable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator==(X&& x, Y&& y) - { return hana::equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::comparable_operators<typename hana::tag_of<X>::type>::value || - detail::comparable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator!=(X&& x, Y&& y) - { return hana::not_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } - } // end namespace operators -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_COMPARABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/iterable.hpp b/contrib/restricted/boost/boost/hana/detail/operators/iterable.hpp deleted file mode 100644 index 6dcb6bc25e..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/iterable.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*! -@file -Defines operators for Iterables. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP -#define BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/at.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Derived> - struct iterable_operators { - template <typename N> - constexpr decltype(auto) operator[](N&& n) & { - return hana::at(static_cast<Derived&>(*this), - static_cast<N&&>(n)); - } - - template <typename N> - constexpr decltype(auto) operator[](N&& n) const& { - return hana::at(static_cast<Derived const&>(*this), - static_cast<N&&>(n)); - } - - template <typename N> - constexpr decltype(auto) operator[](N&& n) && { - return hana::at(static_cast<Derived&&>(*this), - static_cast<N&&>(n)); - } - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_ITERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/logical.hpp b/contrib/restricted/boost/boost/hana/detail/operators/logical.hpp deleted file mode 100644 index 4645ca2bb4..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/logical.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines logical operators. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP -#define BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/fwd/and.hpp> -#include <boost/hana/fwd/not.hpp> -#include <boost/hana/fwd/or.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Tag> - struct logical_operators { - static constexpr bool value = false; - }; - - namespace operators { - template <typename X, typename Y, typename = typename std::enable_if< - detail::logical_operators<typename hana::tag_of<X>::type>::value || - detail::logical_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator||(X&& x, Y&& y) - { return hana::or_(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::logical_operators<typename hana::tag_of<X>::type>::value || - detail::logical_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator&&(X&& x, Y&& y) - { return hana::and_(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename = typename std::enable_if< - detail::logical_operators<typename hana::tag_of<X>::type>::value - >::type> - constexpr auto operator!(X&& x) - { return hana::not_(static_cast<X&&>(x)); } - } // end namespace operators -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_LOGICAL_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/monad.hpp b/contrib/restricted/boost/boost/hana/detail/operators/monad.hpp deleted file mode 100644 index ccc421c56a..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/monad.hpp +++ /dev/null @@ -1,35 +0,0 @@ -/*! -@file -Defines operators for Monads. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP -#define BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/fwd/chain.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Tag> - struct monad_operators { - static constexpr bool value = false; - }; - - namespace operators { - template <typename Xs, typename F, typename = typename std::enable_if< - detail::monad_operators<typename hana::tag_of<Xs>::type>::value - >::type> - constexpr auto operator|(Xs&& xs, F&& f) - { return hana::chain(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } - } // end namespace operators -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_MONAD_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/orderable.hpp b/contrib/restricted/boost/boost/hana/detail/operators/orderable.hpp deleted file mode 100644 index cf46829a04..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/orderable.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/*! -@file -Defines operators for Orderables. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP -#define BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/fwd/greater.hpp> -#include <boost/hana/fwd/greater_equal.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/fwd/less_equal.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Tag> - struct orderable_operators { - static constexpr bool value = false; - }; - - namespace operators { - template <typename X, typename Y, typename = typename std::enable_if< - detail::orderable_operators<typename hana::tag_of<X>::type>::value || - detail::orderable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator<(X&& x, Y&& y) - { return hana::less(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::orderable_operators<typename hana::tag_of<X>::type>::value || - detail::orderable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator>(X&& x, Y&& y) - { return hana::greater(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::orderable_operators<typename hana::tag_of<X>::type>::value || - detail::orderable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator<=(X&& x, Y&& y) - { return hana::less_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } - - template <typename X, typename Y, typename = typename std::enable_if< - detail::orderable_operators<typename hana::tag_of<X>::type>::value || - detail::orderable_operators<typename hana::tag_of<Y>::type>::value - >::type> - constexpr auto operator>=(X&& x, Y&& y) - { return hana::greater_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); } - } // end namespace operators -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_ORDERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/operators/searchable.hpp b/contrib/restricted/boost/boost/hana/detail/operators/searchable.hpp deleted file mode 100644 index 69d67465da..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/operators/searchable.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*! -@file -Defines operators for Searchables. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP -#define BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/at_key.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename Derived> - struct searchable_operators { - template <typename Key> - constexpr decltype(auto) operator[](Key&& key) & { - return hana::at_key(static_cast<Derived&>(*this), - static_cast<Key&&>(key)); - } - - template <typename Key> - constexpr decltype(auto) operator[](Key&& key) && { - return hana::at_key(static_cast<Derived&&>(*this), - static_cast<Key&&>(key)); - } - - template <typename Key> - constexpr decltype(auto) operator[](Key&& key) const& { - return hana::at_key(static_cast<Derived const&>(*this), - static_cast<Key&&>(key)); - } - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_OPERATORS_SEARCHABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/preprocessor.hpp b/contrib/restricted/boost/boost/hana/detail/preprocessor.hpp deleted file mode 100644 index 6a141187e7..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/preprocessor.hpp +++ /dev/null @@ -1,34 +0,0 @@ -/*! -@file -Defines generally useful preprocessor macros. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_PREPROCESSOR_HPP -#define BOOST_HANA_DETAIL_PREPROCESSOR_HPP - -//! @ingroup group-details -//! Expands to the concatenation of its two arguments. -#define BOOST_HANA_PP_CONCAT(x, y) BOOST_HANA_PP_CONCAT_PRIMITIVE(x, y) -#define BOOST_HANA_PP_CONCAT_PRIMITIVE(x, y) x ## y - -//! @ingroup group-details -//! Expands to the stringized version of its argument. -#define BOOST_HANA_PP_STRINGIZE(...) BOOST_HANA_PP_STRINGIZE_PRIMITIVE(__VA_ARGS__) -#define BOOST_HANA_PP_STRINGIZE_PRIMITIVE(...) #__VA_ARGS__ - -//! @ingroup group-details -//! Expands to its first argument. -#define BOOST_HANA_PP_FRONT(...) BOOST_HANA_PP_FRONT_IMPL(__VA_ARGS__, ) -#define BOOST_HANA_PP_FRONT_IMPL(e0, ...) e0 - -//! @ingroup group-details -//! Expands to all of its arguments, except for the first one. -//! -//! This macro may not be called with less than 2 arguments. -#define BOOST_HANA_PP_DROP_FRONT(e0, ...) __VA_ARGS__ - -#endif // !BOOST_HANA_DETAIL_PREPROCESSOR_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/std_common_type.hpp b/contrib/restricted/boost/boost/hana/detail/std_common_type.hpp deleted file mode 100644 index b5fe6f318e..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/std_common_type.hpp +++ /dev/null @@ -1,36 +0,0 @@ -/*! -@file -Defines a SFINAE-friendly version of `std::common_type`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP -#define BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @ingroup group-details - //! Equivalent to `std::common_type`, except it is SFINAE-friendly and - //! does not support custom specializations. - template <typename T, typename U, typename = void> - struct std_common_type { }; - - template <typename T, typename U> - struct std_common_type<T, U, decltype((void)( - true ? std::declval<T>() : std::declval<U>() - ))> { - using type = typename detail::decay< - decltype(true ? std::declval<T>() : std::declval<U>()) - >::type; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_STD_COMMON_TYPE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/struct_macros.hpp b/contrib/restricted/boost/boost/hana/detail/struct_macros.hpp deleted file mode 100644 index e99ab4fac8..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/struct_macros.hpp +++ /dev/null @@ -1,2768 +0,0 @@ - - - - -/*! -@file -Defines the `BOOST_HANA_DEFINE_STRUCT`, `BOOST_HANA_ADAPT_STRUCT`, and -`BOOST_HANA_ADAPT_ADT` macros. - -@copyright Louis Dionne 2013-2017 -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_PP_NARG -////////////////////////////////////////////////////////////////////////////// -//! @ingroup group-details -//! Macro expanding to the number of arguments it is passed. -//! -//! Specifically, `BOOST_HANA_PP_NARG(x1, ..., xn)` expands to `n`. It is -//! an error to call this macro with 0 arguments. -#define BOOST_HANA_PP_NARG(...) \ - BOOST_HANA_PP_NARG_IMPL(__VA_ARGS__, 40,39,38,37,36,35,34,33,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,) - -#define BOOST_HANA_PP_NARG_IMPL(e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40, N, ...) N - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_PP_BACK -////////////////////////////////////////////////////////////////////////////// -//! @ingroup group-details -//! Expands to its last argument. -#define BOOST_HANA_PP_BACK(...) \ - BOOST_HANA_PP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) - -#define BOOST_HANA_PP_BACK_IMPL(N, ...) \ - BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_BACK_IMPL_, N)(__VA_ARGS__) - - -#define BOOST_HANA_PP_BACK_IMPL_1(e1) e1 - -#define BOOST_HANA_PP_BACK_IMPL_2(e1, e2) e2 - -#define BOOST_HANA_PP_BACK_IMPL_3(e1, e2, e3) e3 - -#define BOOST_HANA_PP_BACK_IMPL_4(e1, e2, e3, e4) e4 - -#define BOOST_HANA_PP_BACK_IMPL_5(e1, e2, e3, e4, e5) e5 - -#define BOOST_HANA_PP_BACK_IMPL_6(e1, e2, e3, e4, e5, e6) e6 - -#define BOOST_HANA_PP_BACK_IMPL_7(e1, e2, e3, e4, e5, e6, e7) e7 - -#define BOOST_HANA_PP_BACK_IMPL_8(e1, e2, e3, e4, e5, e6, e7, e8) e8 - -#define BOOST_HANA_PP_BACK_IMPL_9(e1, e2, e3, e4, e5, e6, e7, e8, e9) e9 - -#define BOOST_HANA_PP_BACK_IMPL_10(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) e10 - -#define BOOST_HANA_PP_BACK_IMPL_11(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) e11 - -#define BOOST_HANA_PP_BACK_IMPL_12(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) e12 - -#define BOOST_HANA_PP_BACK_IMPL_13(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) e13 - -#define BOOST_HANA_PP_BACK_IMPL_14(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) e14 - -#define BOOST_HANA_PP_BACK_IMPL_15(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) e15 - -#define BOOST_HANA_PP_BACK_IMPL_16(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) e16 - -#define BOOST_HANA_PP_BACK_IMPL_17(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) e17 - -#define BOOST_HANA_PP_BACK_IMPL_18(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) e18 - -#define BOOST_HANA_PP_BACK_IMPL_19(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) e19 - -#define BOOST_HANA_PP_BACK_IMPL_20(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) e20 - -#define BOOST_HANA_PP_BACK_IMPL_21(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) e21 - -#define BOOST_HANA_PP_BACK_IMPL_22(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) e22 - -#define BOOST_HANA_PP_BACK_IMPL_23(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) e23 - -#define BOOST_HANA_PP_BACK_IMPL_24(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) e24 - -#define BOOST_HANA_PP_BACK_IMPL_25(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) e25 - -#define BOOST_HANA_PP_BACK_IMPL_26(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) e26 - -#define BOOST_HANA_PP_BACK_IMPL_27(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) e27 - -#define BOOST_HANA_PP_BACK_IMPL_28(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) e28 - -#define BOOST_HANA_PP_BACK_IMPL_29(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) e29 - -#define BOOST_HANA_PP_BACK_IMPL_30(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) e30 - -#define BOOST_HANA_PP_BACK_IMPL_31(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) e31 - -#define BOOST_HANA_PP_BACK_IMPL_32(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) e32 - -#define BOOST_HANA_PP_BACK_IMPL_33(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) e33 - -#define BOOST_HANA_PP_BACK_IMPL_34(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) e34 - -#define BOOST_HANA_PP_BACK_IMPL_35(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) e35 - -#define BOOST_HANA_PP_BACK_IMPL_36(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) e36 - -#define BOOST_HANA_PP_BACK_IMPL_37(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) e37 - -#define BOOST_HANA_PP_BACK_IMPL_38(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) e38 - -#define BOOST_HANA_PP_BACK_IMPL_39(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) e39 - -#define BOOST_HANA_PP_BACK_IMPL_40(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) e40 - - -////////////////////////////////////////////////////////////////////////////// -// BOOST_HANA_PP_DROP_BACK -////////////////////////////////////////////////////////////////////////////// -//! @ingroup group-details -//! Expands to all of its arguments, except for the last one. -#define BOOST_HANA_PP_DROP_BACK(...) \ - BOOST_HANA_PP_DROP_BACK_IMPL(BOOST_HANA_PP_NARG(__VA_ARGS__), __VA_ARGS__) - -#define BOOST_HANA_PP_DROP_BACK_IMPL(N, ...) \ - BOOST_HANA_PP_CONCAT(BOOST_HANA_PP_DROP_BACK_IMPL_, N)(__VA_ARGS__) - - -#define BOOST_HANA_PP_DROP_BACK_IMPL_1(e1) - -#define BOOST_HANA_PP_DROP_BACK_IMPL_2(e1, e2)e1 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_3(e1, e2, e3)e1, e2 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_4(e1, e2, e3, e4)e1, e2, e3 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_5(e1, e2, e3, e4, e5)e1, e2, e3, e4 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_6(e1, e2, e3, e4, e5, e6)e1, e2, e3, e4, e5 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_7(e1, e2, e3, e4, e5, e6, e7)e1, e2, e3, e4, e5, e6 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_8(e1, e2, e3, e4, e5, e6, e7, e8)e1, e2, e3, e4, e5, e6, e7 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_9(e1, e2, e3, e4, e5, e6, e7, e8, e9)e1, e2, e3, e4, e5, e6, e7, e8 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_10(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10)e1, e2, e3, e4, e5, e6, e7, e8, e9 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_11(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_12(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_13(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_14(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_15(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_16(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_17(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_18(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_19(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_20(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_21(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_22(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_23(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_24(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_25(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_26(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_27(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_28(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_29(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_30(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_31(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_32(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_33(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_34(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_35(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_36(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_37(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_38(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_39(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38 - -#define BOOST_HANA_PP_DROP_BACK_IMPL_40(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40)e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39 - - -////////////////////////////////////////////////////////////////////////////// -// 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__) - - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_1(TYPE ) \ - 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( \ - \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - \ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_2(TYPE , m1) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_3(TYPE , m1, m2) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_4(TYPE , m1, m2, m3) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_5(TYPE , m1, m2, m3, m4) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38), BOOST_HANA_PP_STRINGIZE(m39) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m39), &TYPE::m39>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_STRUCT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(m1), BOOST_HANA_PP_STRINGIZE(m2), BOOST_HANA_PP_STRINGIZE(m3), BOOST_HANA_PP_STRINGIZE(m4), BOOST_HANA_PP_STRINGIZE(m5), BOOST_HANA_PP_STRINGIZE(m6), BOOST_HANA_PP_STRINGIZE(m7), BOOST_HANA_PP_STRINGIZE(m8), BOOST_HANA_PP_STRINGIZE(m9), BOOST_HANA_PP_STRINGIZE(m10), BOOST_HANA_PP_STRINGIZE(m11), BOOST_HANA_PP_STRINGIZE(m12), BOOST_HANA_PP_STRINGIZE(m13), BOOST_HANA_PP_STRINGIZE(m14), BOOST_HANA_PP_STRINGIZE(m15), BOOST_HANA_PP_STRINGIZE(m16), BOOST_HANA_PP_STRINGIZE(m17), BOOST_HANA_PP_STRINGIZE(m18), BOOST_HANA_PP_STRINGIZE(m19), BOOST_HANA_PP_STRINGIZE(m20), BOOST_HANA_PP_STRINGIZE(m21), BOOST_HANA_PP_STRINGIZE(m22), BOOST_HANA_PP_STRINGIZE(m23), BOOST_HANA_PP_STRINGIZE(m24), BOOST_HANA_PP_STRINGIZE(m25), BOOST_HANA_PP_STRINGIZE(m26), BOOST_HANA_PP_STRINGIZE(m27), BOOST_HANA_PP_STRINGIZE(m28), BOOST_HANA_PP_STRINGIZE(m29), BOOST_HANA_PP_STRINGIZE(m30), BOOST_HANA_PP_STRINGIZE(m31), BOOST_HANA_PP_STRINGIZE(m32), BOOST_HANA_PP_STRINGIZE(m33), BOOST_HANA_PP_STRINGIZE(m34), BOOST_HANA_PP_STRINGIZE(m35), BOOST_HANA_PP_STRINGIZE(m36), BOOST_HANA_PP_STRINGIZE(m37), BOOST_HANA_PP_STRINGIZE(m38), BOOST_HANA_PP_STRINGIZE(m39), BOOST_HANA_PP_STRINGIZE(m40) \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m1), &TYPE::m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m2), &TYPE::m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m3), &TYPE::m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m4), &TYPE::m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m5), &TYPE::m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m6), &TYPE::m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m7), &TYPE::m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m8), &TYPE::m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m9), &TYPE::m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m10), &TYPE::m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m11), &TYPE::m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m12), &TYPE::m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m13), &TYPE::m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m14), &TYPE::m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m15), &TYPE::m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m16), &TYPE::m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m17), &TYPE::m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m18), &TYPE::m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m19), &TYPE::m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m20), &TYPE::m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m21), &TYPE::m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m22), &TYPE::m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m23), &TYPE::m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m24), &TYPE::m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m25), &TYPE::m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m26), &TYPE::m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m27), &TYPE::m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m28), &TYPE::m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m29), &TYPE::m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m30), &TYPE::m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m31), &TYPE::m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m32), &TYPE::m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m33), &TYPE::m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m34), &TYPE::m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m35), &TYPE::m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m36), &TYPE::m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m37), &TYPE::m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m38), &TYPE::m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m39), &TYPE::m39>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::m40), &TYPE::m40>{})\ - ); \ - } \ - }; \ - }} \ -/**/ - - -////////////////////////////////////////////////////////////////////////////// -// 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__) - - -#define BOOST_HANA_ADAPT_ADT_IMPL_1(TYPE ) \ - 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( \ - \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - \ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_2(TYPE , m1) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_3(TYPE , m1, m2) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_4(TYPE , m1, m2, m3) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_5(TYPE , m1, m2, m3, m4) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m39)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), BOOST_HANA_PP_DROP_FRONT m39)\ - ); \ - } \ - }; \ - }} \ -/**/ - -#define BOOST_HANA_ADAPT_ADT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ - 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( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m39), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_FRONT m40)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), BOOST_HANA_PP_DROP_FRONT m1), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), BOOST_HANA_PP_DROP_FRONT m2), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), BOOST_HANA_PP_DROP_FRONT m3), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), BOOST_HANA_PP_DROP_FRONT m4), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), BOOST_HANA_PP_DROP_FRONT m5), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), BOOST_HANA_PP_DROP_FRONT m6), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), BOOST_HANA_PP_DROP_FRONT m7), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), BOOST_HANA_PP_DROP_FRONT m8), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), BOOST_HANA_PP_DROP_FRONT m9), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), BOOST_HANA_PP_DROP_FRONT m10), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), BOOST_HANA_PP_DROP_FRONT m11), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), BOOST_HANA_PP_DROP_FRONT m12), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), BOOST_HANA_PP_DROP_FRONT m13), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), BOOST_HANA_PP_DROP_FRONT m14), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), BOOST_HANA_PP_DROP_FRONT m15), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), BOOST_HANA_PP_DROP_FRONT m16), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), BOOST_HANA_PP_DROP_FRONT m17), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), BOOST_HANA_PP_DROP_FRONT m18), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), BOOST_HANA_PP_DROP_FRONT m19), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), BOOST_HANA_PP_DROP_FRONT m20), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), BOOST_HANA_PP_DROP_FRONT m21), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), BOOST_HANA_PP_DROP_FRONT m22), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), BOOST_HANA_PP_DROP_FRONT m23), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), BOOST_HANA_PP_DROP_FRONT m24), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), BOOST_HANA_PP_DROP_FRONT m25), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), BOOST_HANA_PP_DROP_FRONT m26), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), BOOST_HANA_PP_DROP_FRONT m27), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), BOOST_HANA_PP_DROP_FRONT m28), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), BOOST_HANA_PP_DROP_FRONT m29), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), BOOST_HANA_PP_DROP_FRONT m30), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), BOOST_HANA_PP_DROP_FRONT m31), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), BOOST_HANA_PP_DROP_FRONT m32), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), BOOST_HANA_PP_DROP_FRONT m33), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), BOOST_HANA_PP_DROP_FRONT m34), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), BOOST_HANA_PP_DROP_FRONT m35), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), BOOST_HANA_PP_DROP_FRONT m36), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), BOOST_HANA_PP_DROP_FRONT m37), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), BOOST_HANA_PP_DROP_FRONT m38), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), BOOST_HANA_PP_DROP_FRONT m39), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), BOOST_HANA_PP_DROP_FRONT m40)\ - ); \ - } \ - }; \ - }} \ -/**/ - - -////////////////////////////////////////////////////////////////////////////// -// 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__) - - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_1(TYPE ) \ - \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - \ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - \ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_2(TYPE , m1) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_3(TYPE , m1, m2) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_4(TYPE , m1, m2, m3) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_5(TYPE , m1, m2, m3, m4) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_6(TYPE , m1, m2, m3, m4, m5) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_7(TYPE , m1, m2, m3, m4, m5, m6) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_8(TYPE , m1, m2, m3, m4, m5, m6, m7) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_9(TYPE , m1, m2, m3, m4, m5, m6, m7, m8) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_10(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_11(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_12(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_13(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_14(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_15(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_16(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_17(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_18(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_19(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_20(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_21(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_22(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_23(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_24(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_25(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_26(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_27(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_28(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_29(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_30(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_31(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_32(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_33(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_34(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_35(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_36(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_37(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_38(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_39(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_40(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; BOOST_HANA_PP_DROP_BACK m39 BOOST_HANA_PP_BACK m39; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m39)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m39), &TYPE::BOOST_HANA_PP_BACK m39>{})\ - ); \ - } \ - } \ -/**/ - -#define BOOST_HANA_DEFINE_STRUCT_IMPL_41(TYPE , m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, m16, m17, m18, m19, m20, m21, m22, m23, m24, m25, m26, m27, m28, m29, m30, m31, m32, m33, m34, m35, m36, m37, m38, m39, m40) \ - BOOST_HANA_PP_DROP_BACK m1 BOOST_HANA_PP_BACK m1; BOOST_HANA_PP_DROP_BACK m2 BOOST_HANA_PP_BACK m2; BOOST_HANA_PP_DROP_BACK m3 BOOST_HANA_PP_BACK m3; BOOST_HANA_PP_DROP_BACK m4 BOOST_HANA_PP_BACK m4; BOOST_HANA_PP_DROP_BACK m5 BOOST_HANA_PP_BACK m5; BOOST_HANA_PP_DROP_BACK m6 BOOST_HANA_PP_BACK m6; BOOST_HANA_PP_DROP_BACK m7 BOOST_HANA_PP_BACK m7; BOOST_HANA_PP_DROP_BACK m8 BOOST_HANA_PP_BACK m8; BOOST_HANA_PP_DROP_BACK m9 BOOST_HANA_PP_BACK m9; BOOST_HANA_PP_DROP_BACK m10 BOOST_HANA_PP_BACK m10; BOOST_HANA_PP_DROP_BACK m11 BOOST_HANA_PP_BACK m11; BOOST_HANA_PP_DROP_BACK m12 BOOST_HANA_PP_BACK m12; BOOST_HANA_PP_DROP_BACK m13 BOOST_HANA_PP_BACK m13; BOOST_HANA_PP_DROP_BACK m14 BOOST_HANA_PP_BACK m14; BOOST_HANA_PP_DROP_BACK m15 BOOST_HANA_PP_BACK m15; BOOST_HANA_PP_DROP_BACK m16 BOOST_HANA_PP_BACK m16; BOOST_HANA_PP_DROP_BACK m17 BOOST_HANA_PP_BACK m17; BOOST_HANA_PP_DROP_BACK m18 BOOST_HANA_PP_BACK m18; BOOST_HANA_PP_DROP_BACK m19 BOOST_HANA_PP_BACK m19; BOOST_HANA_PP_DROP_BACK m20 BOOST_HANA_PP_BACK m20; BOOST_HANA_PP_DROP_BACK m21 BOOST_HANA_PP_BACK m21; BOOST_HANA_PP_DROP_BACK m22 BOOST_HANA_PP_BACK m22; BOOST_HANA_PP_DROP_BACK m23 BOOST_HANA_PP_BACK m23; BOOST_HANA_PP_DROP_BACK m24 BOOST_HANA_PP_BACK m24; BOOST_HANA_PP_DROP_BACK m25 BOOST_HANA_PP_BACK m25; BOOST_HANA_PP_DROP_BACK m26 BOOST_HANA_PP_BACK m26; BOOST_HANA_PP_DROP_BACK m27 BOOST_HANA_PP_BACK m27; BOOST_HANA_PP_DROP_BACK m28 BOOST_HANA_PP_BACK m28; BOOST_HANA_PP_DROP_BACK m29 BOOST_HANA_PP_BACK m29; BOOST_HANA_PP_DROP_BACK m30 BOOST_HANA_PP_BACK m30; BOOST_HANA_PP_DROP_BACK m31 BOOST_HANA_PP_BACK m31; BOOST_HANA_PP_DROP_BACK m32 BOOST_HANA_PP_BACK m32; BOOST_HANA_PP_DROP_BACK m33 BOOST_HANA_PP_BACK m33; BOOST_HANA_PP_DROP_BACK m34 BOOST_HANA_PP_BACK m34; BOOST_HANA_PP_DROP_BACK m35 BOOST_HANA_PP_BACK m35; BOOST_HANA_PP_DROP_BACK m36 BOOST_HANA_PP_BACK m36; BOOST_HANA_PP_DROP_BACK m37 BOOST_HANA_PP_BACK m37; BOOST_HANA_PP_DROP_BACK m38 BOOST_HANA_PP_BACK m38; BOOST_HANA_PP_DROP_BACK m39 BOOST_HANA_PP_BACK m39; BOOST_HANA_PP_DROP_BACK m40 BOOST_HANA_PP_BACK m40; \ - \ - struct hana_accessors_impl { \ - static constexpr auto apply() { \ - struct member_names { \ - static constexpr auto get() { \ - return ::boost::hana::make_tuple( \ - BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m1), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m2), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m3), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m4), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m5), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m6), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m7), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m8), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m9), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m10), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m11), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m12), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m13), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m14), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m15), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m16), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m17), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m18), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m19), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m20), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m21), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m22), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m23), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m24), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m25), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m26), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m27), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m28), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m29), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m30), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m31), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m32), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m33), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m34), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m35), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m36), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m37), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m38), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m39), BOOST_HANA_PP_STRINGIZE(BOOST_HANA_PP_BACK m40)\ - ); \ - } \ - }; \ - return ::boost::hana::make_tuple( \ - ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<0, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m1), &TYPE::BOOST_HANA_PP_BACK m1>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<1, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m2), &TYPE::BOOST_HANA_PP_BACK m2>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<2, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m3), &TYPE::BOOST_HANA_PP_BACK m3>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<3, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m4), &TYPE::BOOST_HANA_PP_BACK m4>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<4, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m5), &TYPE::BOOST_HANA_PP_BACK m5>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<5, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m6), &TYPE::BOOST_HANA_PP_BACK m6>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<6, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m7), &TYPE::BOOST_HANA_PP_BACK m7>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<7, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m8), &TYPE::BOOST_HANA_PP_BACK m8>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<8, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m9), &TYPE::BOOST_HANA_PP_BACK m9>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<9, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m10), &TYPE::BOOST_HANA_PP_BACK m10>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<10, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m11), &TYPE::BOOST_HANA_PP_BACK m11>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<11, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m12), &TYPE::BOOST_HANA_PP_BACK m12>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<12, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m13), &TYPE::BOOST_HANA_PP_BACK m13>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<13, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m14), &TYPE::BOOST_HANA_PP_BACK m14>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<14, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m15), &TYPE::BOOST_HANA_PP_BACK m15>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<15, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m16), &TYPE::BOOST_HANA_PP_BACK m16>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<16, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m17), &TYPE::BOOST_HANA_PP_BACK m17>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<17, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m18), &TYPE::BOOST_HANA_PP_BACK m18>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<18, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m19), &TYPE::BOOST_HANA_PP_BACK m19>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<19, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m20), &TYPE::BOOST_HANA_PP_BACK m20>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<20, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m21), &TYPE::BOOST_HANA_PP_BACK m21>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<21, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m22), &TYPE::BOOST_HANA_PP_BACK m22>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<22, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m23), &TYPE::BOOST_HANA_PP_BACK m23>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<23, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m24), &TYPE::BOOST_HANA_PP_BACK m24>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<24, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m25), &TYPE::BOOST_HANA_PP_BACK m25>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<25, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m26), &TYPE::BOOST_HANA_PP_BACK m26>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<26, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m27), &TYPE::BOOST_HANA_PP_BACK m27>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<27, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m28), &TYPE::BOOST_HANA_PP_BACK m28>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<28, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m29), &TYPE::BOOST_HANA_PP_BACK m29>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<29, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m30), &TYPE::BOOST_HANA_PP_BACK m30>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<30, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m31), &TYPE::BOOST_HANA_PP_BACK m31>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<31, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m32), &TYPE::BOOST_HANA_PP_BACK m32>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<32, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m33), &TYPE::BOOST_HANA_PP_BACK m33>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<33, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m34), &TYPE::BOOST_HANA_PP_BACK m34>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<34, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m35), &TYPE::BOOST_HANA_PP_BACK m35>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<35, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m36), &TYPE::BOOST_HANA_PP_BACK m36>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<36, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m37), &TYPE::BOOST_HANA_PP_BACK m37>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<37, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m38), &TYPE::BOOST_HANA_PP_BACK m38>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<38, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m39), &TYPE::BOOST_HANA_PP_BACK m39>{}), ::boost::hana::make_pair(::boost::hana::struct_detail::prepare_member_name<39, member_names>(), ::boost::hana::struct_detail::member_ptr<decltype(&TYPE::BOOST_HANA_PP_BACK m40), &TYPE::BOOST_HANA_PP_BACK m40>{})\ - ); \ - } \ - } \ -/**/ - - -#endif // !BOOST_HANA_DETAIL_STRUCT_MACROS_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/type_at.hpp b/contrib/restricted/boost/boost/hana/detail/type_at.hpp deleted file mode 100644 index c7b8311f47..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/type_at.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::type_at`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_TYPE_AT_HPP -#define BOOST_HANA_DETAIL_TYPE_AT_HPP - -#include <boost/hana/config.hpp> - -#include <cstddef> -#include <utility> - - -// If possible, use an intrinsic provided by Clang -#if defined(__has_builtin) -# if __has_builtin(__type_pack_element) -# define BOOST_HANA_USE_TYPE_PACK_ELEMENT_INTRINSIC -# endif -#endif - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - namespace td { - template <std::size_t I, typename T> - struct elt { using type = T; }; - - template <typename Indices, typename ...T> - struct indexer; - - template <std::size_t ...I, typename ...T> - struct indexer<std::index_sequence<I...>, T...> - : elt<I, T>... - { }; - - template <std::size_t I, typename T> - elt<I, T> get_elt(elt<I, T> const&); - } - - //! @ingroup group-details - //! Classic MPL-style metafunction returning the nth element of a type - //! parameter pack. - template <std::size_t n, typename ...T> - struct type_at { -#if defined(BOOST_HANA_USE_TYPE_PACK_ELEMENT_INTRINSIC) - using type = __type_pack_element<n, T...>; -#else - using Indexer = td::indexer<std::make_index_sequence<sizeof...(T)>, T...>; - using type = typename decltype(td::get_elt<n>(Indexer{}))::type; -#endif - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_TYPE_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/type_foldl1.hpp b/contrib/restricted/boost/boost/hana/detail/type_foldl1.hpp deleted file mode 100644 index b65e3463fe..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/type_foldl1.hpp +++ /dev/null @@ -1,145 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::type_foldl1`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP -#define BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <unsigned n> - struct type_foldl1_t; - - template <> - struct type_foldl1_t<0> { - template < - template <typename ...> class f, - typename state - > - using result = state; - }; - - template <> - struct type_foldl1_t<1> { - template < - template <typename ...> class f, - typename state, - typename x1 - > - using result = typename f<state, x1>::type; - }; - - template <> - struct type_foldl1_t<2> { - template < - template <typename ...> class f, - typename state, - typename x1, typename x2 - > - using result = typename f<typename f<state, x1>::type, x2>::type; - }; - - template <> - struct type_foldl1_t<3> { - template < - template <typename ...> class f, - typename state, - typename x1, typename x2, typename x3 - > - using result = typename f< - typename f< - typename f<state, x1>::type, - x2 - >::type, - x3 - >::type; - }; - - template <> - struct type_foldl1_t<4> { - template < - template <typename ...> class f, - typename state, - typename x1, typename x2, typename x3, typename x4 - > - using result = typename f< - typename f< - typename f< - typename f<state, x1>::type, - x2 - >::type, - x3 - >::type, - x4 - >::type; - }; - - template <> - struct type_foldl1_t<5> { - template < - template <typename ...> class f, - typename state, - typename x1, typename x2, typename x3, typename x4, typename x5 - > - using result = typename f< - typename f< - typename f< - typename f< - typename f<state, x1>::type, - x2 - >::type, - x3 - >::type, - x4 - >::type, - x5 - >::type; - }; - - template <> - struct type_foldl1_t<6> { - template < - template <typename ...> class f, - typename state, - typename x1, typename x2, typename x3, typename x4, typename x5, typename x6, - typename ...xs - > - using result = - typename type_foldl1_t<(sizeof...(xs) > 6 ? 6 : sizeof...(xs))>:: - template result< - f, - typename f< - typename f< - typename f< - typename f< - typename f< - typename f<state, x1>::type, - x2 - >::type, - x3 - >::type, - x4 - >::type, - x5 - >::type, - x6 - >::type, - xs... - >; - }; - - template <template <typename ...> class f, typename x1, typename ...xn> - struct type_foldl1 { - using type = typename type_foldl1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))> - ::template result<f, x1, xn...>; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_TYPE_FOLDL1_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/type_foldr1.hpp b/contrib/restricted/boost/boost/hana/detail/type_foldr1.hpp deleted file mode 100644 index badf1b03d6..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/type_foldr1.hpp +++ /dev/null @@ -1,149 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::type_foldr1`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP -#define BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <unsigned n> - struct type_foldr1_t; - - template <> - struct type_foldr1_t<0> { - template < - template <typename ...> class f, - typename state - > - using result = state; - }; - - template <> - struct type_foldr1_t<1> { - template < - template <typename ...> class f, - typename x1, - typename state - > - using result = typename f<x1, state>::type; - }; - - template <> - struct type_foldr1_t<2> { - template < - template <typename ...> class f, - typename x1, typename x2, - typename state - > - using result = typename f<x1, typename f<x2, state>::type>::type; - }; - - template <> - struct type_foldr1_t<3> { - template < - template <typename ...> class f, - typename x1, typename x2, typename x3, - typename state - > - using result = typename f< - x1, - typename f< - x2, - typename f< - x3, - state - >::type - >::type - >::type; - }; - - template <> - struct type_foldr1_t<4> { - template < - template <typename ...> class f, - typename x1, typename x2, typename x3, typename x4, - typename state - > - using result = typename f< - x1, - typename f< - x2, - typename f< - x3, - typename f< - x4, - state - >::type - >::type - >::type - >::type; - }; - - template <> - struct type_foldr1_t<5> { - template < - template <typename ...> class f, - typename x1, typename x2, typename x3, typename x4, typename x5, - typename state - > - using result = typename f< - x1, - typename f< - x2, - typename f< - x3, - typename f< - x4, - typename f< - x5, - state - >::type - >::type - >::type - >::type - >::type; - }; - - template <> - struct type_foldr1_t<6> { - template < - template <typename ...> class f, - typename x1, typename x2, typename x3, typename x4, typename x5, typename x6, - typename ...xs - > - using result = - typename f< - x1, - typename f< - x2, - typename f< - x3, - typename f< - x4, - typename f< - x5, - typename type_foldr1_t<(sizeof...(xs) > 6 ? 6 : sizeof...(xs))>:: - template result<f, x6, xs...> - >::type - >::type - >::type - >::type - >::type; - }; - - template <template <typename ...> class f, typename x1, typename ...xn> - struct type_foldr1 { - using type = typename type_foldr1_t<(sizeof...(xn) > 6 ? 6 : sizeof...(xn))> - ::template result<f, x1, xn...>; - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_TYPE_FOLDR1_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/unpack_flatten.hpp b/contrib/restricted/boost/boost/hana/detail/unpack_flatten.hpp deleted file mode 100644 index 65cb3d9507..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/unpack_flatten.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::unpack_flatten`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP -#define BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP - -#include <boost/hana/at.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <std::size_t ...Lengths> - struct flatten_indices { - // avoid empty arrays by appending 0 to `lengths` - static constexpr std::size_t lengths[sizeof...(Lengths) + 1] = {Lengths..., 0}; - static constexpr auto flat_length = - detail::accumulate(lengths, lengths + sizeof...(Lengths), 0); - - template <bool Inner> - static constexpr auto compute() { - detail::array<std::size_t, flat_length> indices{}; - for (std::size_t index = 0, i = 0; i < sizeof...(Lengths); ++i) - for (std::size_t j = 0; j < lengths[i]; ++j, ++index) - indices[index] = (Inner ? i : j); - return indices; - } - - static constexpr auto inner = compute<true>(); - static constexpr auto outer = compute<false>(); - - template <typename Xs, typename F, std::size_t ...i> - static constexpr decltype(auto) - apply(Xs&& xs, F&& f, std::index_sequence<i...>) { - return static_cast<F&&>(f)( - hana::at_c<outer[i]>(hana::at_c<inner[i]>( - static_cast<Xs&&>(xs) - ))... - ); - } - }; - - struct make_flatten_indices { - template <typename ...Xs> - auto operator()(Xs const& ...xs) const -> detail::flatten_indices< - decltype(hana::length(xs))::value... - >; - }; - - template <typename Xs, typename F> - constexpr decltype(auto) unpack_flatten(Xs&& xs, F&& f) { - using Indices = decltype(hana::unpack(xs, make_flatten_indices{})); - return Indices::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f), - std::make_index_sequence<Indices::flat_length>{}); - } -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_UNPACK_FLATTEN_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/at.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/at.hpp deleted file mode 100644 index 9ef9e2944d..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/at.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::at`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_AT_HPP -#define BOOST_HANA_DETAIL_VARIADIC_AT_HPP - -#include <boost/hana/config.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - template <std::size_t n, typename = std::make_index_sequence<n>> - struct at_type; - - template <std::size_t n, std::size_t ...ignore> - struct at_type<n, std::index_sequence<ignore...>> { - private: - template <typename Nth> - static constexpr auto go(decltype(ignore, (void*)0)..., Nth nth, ...) - { return nth; } - - public: - template <typename ...Xs> - constexpr auto operator()(Xs ...xs) const - { return *go(&xs...); } - }; - - template <std::size_t n> - constexpr at_type<n> at{}; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/drop_into.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/drop_into.hpp deleted file mode 100644 index b31d1e98d5..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/drop_into.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::drop_into`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP -#define BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP - -#include <boost/hana/config.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - template <std::size_t n, typename F, typename = std::make_index_sequence<n>> - struct dropper; - - template <std::size_t n, typename F, std::size_t ...ignore> - struct dropper<n, F, std::index_sequence<ignore...>> { - F f; - - template <typename ...Rest> - constexpr auto go(decltype(ignore, (void*)0)..., Rest ...rest) const - { return f(*rest...); } - - template <typename ...Xs> - constexpr auto operator()(Xs ...xs) const - { return go(&xs...); } - }; - - template <std::size_t n> - struct make_dropper { - template <typename F> - constexpr auto operator()(F f) const - { return dropper<n, decltype(f)>{f}; } - }; - - template <std::size_t n> - constexpr make_dropper<n> drop_into{}; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_DROP_INTO_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/foldl1.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/foldl1.hpp deleted file mode 100644 index 31388028ab..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/foldl1.hpp +++ /dev/null @@ -1,214 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::foldl1`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP -#define BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - //! @cond - template <unsigned int n, typename = when<true>> - struct foldl1_impl; - - template <> - struct foldl1_impl<1> { - template <typename F, typename X1> - static constexpr X1 apply(F&&, X1&& x1) - { return static_cast<X1&&>(x1); } - }; - - template <> - struct foldl1_impl<2> { - template <typename F, typename X1, typename X2> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2) { - return static_cast<F&&>(f)(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)); - } - }; - - template <> - struct foldl1_impl<3> { - template <typename F, typename X1, typename X2, typename X3> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3) { - return f(f(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)), - static_cast<X3&&>(x3)); - } - }; - - template <> - struct foldl1_impl<4> { - template <typename F, typename X1, typename X2, typename X3, typename X4> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) { - return f(f(f(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)), - static_cast<X3&&>(x3)), - static_cast<X4&&>(x4)); - } - }; - - template <> - struct foldl1_impl<5> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) { - return f(f(f(f(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)), - static_cast<X3&&>(x3)), - static_cast<X4&&>(x4)), - static_cast<X5&&>(x5)); - } - }; - - template <> - struct foldl1_impl<6> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6) { - return f(f(f(f(f(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)), - static_cast<X3&&>(x3)), - static_cast<X4&&>(x4)), - static_cast<X5&&>(x5)), - static_cast<X6&&>(x6)); - } - }; - - template <unsigned int n> - struct foldl1_impl<n, when<(n >= 7) && (n < 14)>> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xn> - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , Xn&& ...xn) - { - return foldl1_impl<sizeof...(xn) + 1>::apply( - f, - f(f(f(f(f(f(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)), - static_cast<X3&&>(x3)), - static_cast<X4&&>(x4)), - static_cast<X5&&>(x5)), - static_cast<X6&&>(x6)), - static_cast<X7&&>(x7)), - static_cast<Xn&&>(xn)... - ); - } - }; - - template <unsigned int n> - struct foldl1_impl<n, when<(n >= 14) && (n < 28)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , Xn&& ...xn) - { - return foldl1_impl<sizeof...(xn) + 1>::apply( - f, - f(f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), - static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)) - , static_cast<Xn&&>(xn)...); - - } - }; - - template <unsigned int n> - struct foldl1_impl<n, when<(n >= 28) && (n < 56)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 - , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 - , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 - , Xn&& ...xn) - { - return foldl1_impl<sizeof...(xn) + 1>::apply( - f, - f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), - static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)), - static_cast<X15&&>(x15)), static_cast<X16&&>(x16)), static_cast<X17&&>(x17)), static_cast<X18&&>(x18)), static_cast<X19&&>(x19)), static_cast<X20&&>(x20)), static_cast<X21&&>(x21)), - static_cast<X22&&>(x22)), static_cast<X23&&>(x23)), static_cast<X24&&>(x24)), static_cast<X25&&>(x25)), static_cast<X26&&>(x26)), static_cast<X27&&>(x27)), static_cast<X28&&>(x28)) - , static_cast<Xn&&>(xn)...); - } - }; - - template <unsigned int n> - struct foldl1_impl<n, when<(n >= 56)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 - , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 - , typename X29, typename X30, typename X31, typename X32, typename X33, typename X34, typename X35 - , typename X36, typename X37, typename X38, typename X39, typename X40, typename X41, typename X42 - , typename X43, typename X44, typename X45, typename X46, typename X47, typename X48, typename X49 - , typename X50, typename X51, typename X52, typename X53, typename X54, typename X55, typename X56 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 - , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 - , X29&& x29, X30&& x30, X31&& x31, X32&& x32, X33&& x33, X34&& x34, X35&& x35 - , X36&& x36, X37&& x37, X38&& x38, X39&& x39, X40&& x40, X41&& x41, X42&& x42 - , X43&& x43, X44&& x44, X45&& x45, X46&& x46, X47&& x47, X48&& x48, X49&& x49 - , X50&& x50, X51&& x51, X52&& x52, X53&& x53, X54&& x54, X55&& x55, X56&& x56 - , Xn&& ...xn) - { - return foldl1_impl<sizeof...(xn) + 1>::apply( - f, - f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X1&&>(x1), static_cast<X2&&>(x2)), static_cast<X3&&>(x3)), static_cast<X4&&>(x4)), static_cast<X5&&>(x5)), static_cast<X6&&>(x6)), static_cast<X7&&>(x7)), - static_cast<X8&&>(x8)), static_cast<X9&&>(x9)), static_cast<X10&&>(x10)), static_cast<X11&&>(x11)), static_cast<X12&&>(x12)), static_cast<X13&&>(x13)), static_cast<X14&&>(x14)), - static_cast<X15&&>(x15)), static_cast<X16&&>(x16)), static_cast<X17&&>(x17)), static_cast<X18&&>(x18)), static_cast<X19&&>(x19)), static_cast<X20&&>(x20)), static_cast<X21&&>(x21)), - static_cast<X22&&>(x22)), static_cast<X23&&>(x23)), static_cast<X24&&>(x24)), static_cast<X25&&>(x25)), static_cast<X26&&>(x26)), static_cast<X27&&>(x27)), static_cast<X28&&>(x28)), - static_cast<X29&&>(x29)), static_cast<X30&&>(x30)), static_cast<X31&&>(x31)), static_cast<X32&&>(x32)), static_cast<X33&&>(x33)), static_cast<X34&&>(x34)), static_cast<X35&&>(x35)), - static_cast<X36&&>(x36)), static_cast<X37&&>(x37)), static_cast<X38&&>(x38)), static_cast<X39&&>(x39)), static_cast<X40&&>(x40)), static_cast<X41&&>(x41)), static_cast<X42&&>(x42)), - static_cast<X43&&>(x43)), static_cast<X44&&>(x44)), static_cast<X45&&>(x45)), static_cast<X46&&>(x46)), static_cast<X47&&>(x47)), static_cast<X48&&>(x48)), static_cast<X49&&>(x49)), - static_cast<X50&&>(x50)), static_cast<X51&&>(x51)), static_cast<X52&&>(x52)), static_cast<X53&&>(x53)), static_cast<X54&&>(x54)), static_cast<X55&&>(x55)), static_cast<X56&&>(x56)) - , static_cast<Xn&&>(xn)...); - } - }; - //! @endcond - - struct foldl1_t { - template <typename F, typename X1, typename ...Xn> - constexpr decltype(auto) operator()(F&& f, X1&& x1, Xn&& ...xn) const { - return foldl1_impl<sizeof...(xn) + 1>::apply( - static_cast<F&&>(f), static_cast<X1&&>(x1), static_cast<Xn&&>(xn)... - ); - } - }; - - constexpr foldl1_t foldl1{}; - constexpr auto foldl = foldl1; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDL1_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/foldr1.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/foldr1.hpp deleted file mode 100644 index c7323cdaf8..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/foldr1.hpp +++ /dev/null @@ -1,210 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::foldr1`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP -#define BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - //! @cond - template <unsigned int n, typename = when<true>> - struct foldr1_impl; - - template <> - struct foldr1_impl<1> { - template <typename F, typename X1> - static constexpr X1 apply(F&&, X1&& x1) - { return static_cast<X1&&>(x1); } - }; - - template <> - struct foldr1_impl<2> { - template <typename F, typename X1, typename X2> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2) { - return static_cast<F&&>(f)(static_cast<X1&&>(x1), - static_cast<X2&&>(x2)); - } - }; - - template <> - struct foldr1_impl<3> { - template <typename F, typename X1, typename X2, typename X3> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3) { - return f(static_cast<X1&&>(x1), - f(static_cast<X2&&>(x2), - static_cast<X3&&>(x3))); - } - }; - - template <> - struct foldr1_impl<4> { - template <typename F, typename X1, typename X2, typename X3, typename X4> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) { - return f(static_cast<X1&&>(x1), - f(static_cast<X2&&>(x2), - f(static_cast<X3&&>(x3), - static_cast<X4&&>(x4)))); - } - }; - - template <> - struct foldr1_impl<5> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) { - return f(static_cast<X1&&>(x1), - f(static_cast<X2&&>(x2), - f(static_cast<X3&&>(x3), - f(static_cast<X4&&>(x4), - static_cast<X5&&>(x5))))); - } - }; - - template <> - struct foldr1_impl<6> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6> - static constexpr decltype(auto) apply(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6) { - return f(static_cast<X1&&>(x1), - f(static_cast<X2&&>(x2), - f(static_cast<X3&&>(x3), - f(static_cast<X4&&>(x4), - f(static_cast<X5&&>(x5), - static_cast<X6&&>(x6)))))); - } - }; - - template <unsigned int n> - struct foldr1_impl<n, when<(n >= 7) && (n < 14)>> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xn> - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , Xn&& ...xn) - { - return f(static_cast<X1&&>(x1), - f(static_cast<X2&&>(x2), - f(static_cast<X3&&>(x3), - f(static_cast<X4&&>(x4), - f(static_cast<X5&&>(x5), - f(static_cast<X6&&>(x6), - foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X7&&>(x7), static_cast<Xn&&>(xn)...))))))); - } - }; - - template <unsigned int n> - struct foldr1_impl<n, when<(n >= 14) && (n < 28)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , Xn&& ...xn) - { - return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), - f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), - foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X14&&>(x14), static_cast<Xn&&>(xn)...)))))))))))))); - } - }; - - template <unsigned int n> - struct foldr1_impl<n, when<(n >= 28) && (n < 56)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 - , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 - , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 - , Xn&& ...xn) - { - return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), - f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), f(static_cast<X14&&>(x14), - f(static_cast<X15&&>(x15), f(static_cast<X16&&>(x16), f(static_cast<X17&&>(x17), f(static_cast<X18&&>(x18), f(static_cast<X19&&>(x19), f(static_cast<X20&&>(x20), f(static_cast<X21&&>(x21), - f(static_cast<X22&&>(x22), f(static_cast<X23&&>(x23), f(static_cast<X24&&>(x24), f(static_cast<X25&&>(x25), f(static_cast<X26&&>(x26), f(static_cast<X27&&>(x27), - foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X28&&>(x28), static_cast<Xn&&>(xn)...)))))))))))))))))))))))))))); - } - }; - - template <unsigned int n> - struct foldr1_impl<n, when<(n >= 56)>> { - template < - typename F - , typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7 - , typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14 - , typename X15, typename X16, typename X17, typename X18, typename X19, typename X20, typename X21 - , typename X22, typename X23, typename X24, typename X25, typename X26, typename X27, typename X28 - , typename X29, typename X30, typename X31, typename X32, typename X33, typename X34, typename X35 - , typename X36, typename X37, typename X38, typename X39, typename X40, typename X41, typename X42 - , typename X43, typename X44, typename X45, typename X46, typename X47, typename X48, typename X49 - , typename X50, typename X51, typename X52, typename X53, typename X54, typename X55, typename X56 - , typename ...Xn - > - static constexpr decltype(auto) - apply(F&& f - , X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7 - , X8&& x8, X9&& x9, X10&& x10, X11&& x11, X12&& x12, X13&& x13, X14&& x14 - , X15&& x15, X16&& x16, X17&& x17, X18&& x18, X19&& x19, X20&& x20, X21&& x21 - , X22&& x22, X23&& x23, X24&& x24, X25&& x25, X26&& x26, X27&& x27, X28&& x28 - , X29&& x29, X30&& x30, X31&& x31, X32&& x32, X33&& x33, X34&& x34, X35&& x35 - , X36&& x36, X37&& x37, X38&& x38, X39&& x39, X40&& x40, X41&& x41, X42&& x42 - , X43&& x43, X44&& x44, X45&& x45, X46&& x46, X47&& x47, X48&& x48, X49&& x49 - , X50&& x50, X51&& x51, X52&& x52, X53&& x53, X54&& x54, X55&& x55, X56&& x56 - , Xn&& ...xn) - { - return f(static_cast<X1&&>(x1), f(static_cast<X2&&>(x2), f(static_cast<X3&&>(x3), f(static_cast<X4&&>(x4), f(static_cast<X5&&>(x5), f(static_cast<X6&&>(x6), f(static_cast<X7&&>(x7), - f(static_cast<X8&&>(x8), f(static_cast<X9&&>(x9), f(static_cast<X10&&>(x10), f(static_cast<X11&&>(x11), f(static_cast<X12&&>(x12), f(static_cast<X13&&>(x13), f(static_cast<X14&&>(x14), - f(static_cast<X15&&>(x15), f(static_cast<X16&&>(x16), f(static_cast<X17&&>(x17), f(static_cast<X18&&>(x18), f(static_cast<X19&&>(x19), f(static_cast<X20&&>(x20), f(static_cast<X21&&>(x21), - f(static_cast<X22&&>(x22), f(static_cast<X23&&>(x23), f(static_cast<X24&&>(x24), f(static_cast<X25&&>(x25), f(static_cast<X26&&>(x26), f(static_cast<X27&&>(x27), f(static_cast<X28&&>(x28), - f(static_cast<X29&&>(x29), f(static_cast<X30&&>(x30), f(static_cast<X31&&>(x31), f(static_cast<X32&&>(x32), f(static_cast<X33&&>(x33), f(static_cast<X34&&>(x34), f(static_cast<X35&&>(x35), - f(static_cast<X36&&>(x36), f(static_cast<X37&&>(x37), f(static_cast<X38&&>(x38), f(static_cast<X39&&>(x39), f(static_cast<X40&&>(x40), f(static_cast<X41&&>(x41), f(static_cast<X42&&>(x42), - f(static_cast<X43&&>(x43), f(static_cast<X44&&>(x44), f(static_cast<X45&&>(x45), f(static_cast<X46&&>(x46), f(static_cast<X47&&>(x47), f(static_cast<X48&&>(x48), f(static_cast<X49&&>(x49), - f(static_cast<X50&&>(x50), f(static_cast<X51&&>(x51), f(static_cast<X52&&>(x52), f(static_cast<X53&&>(x53), f(static_cast<X54&&>(x54), f(static_cast<X55&&>(x55), - foldr1_impl<sizeof...(xn) + 1>::apply(f, static_cast<X56&&>(x56), static_cast<Xn&&>(xn)...)))))))))))))))))))))))))))))))))))))))))))))))))))))))); - } - }; - //! @endcond - - struct foldr1_t { - template <typename F, typename X1, typename ...Xn> - constexpr decltype(auto) operator()(F&& f, X1&& x1, Xn&& ...xn) const { - return foldr1_impl<sizeof...(xn) + 1>::apply( - static_cast<F&&>(f), static_cast<X1&&>(x1), static_cast<Xn&&>(xn)... - ); - } - }; - - constexpr foldr1_t foldr1{}; - - struct foldr_t { - template <typename F, typename State, typename ...Xn> - constexpr decltype(auto) operator()(F&& f, State&& state, Xn&& ...xn) const { - return foldr1_impl<sizeof...(xn) + 1>::apply( - static_cast<F&&>(f), static_cast<Xn&&>(xn)..., static_cast<State&&>(state) - ); - } - }; - - constexpr foldr_t foldr{}; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_FOLDR1_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply.hpp deleted file mode 100644 index b276fa4177..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply.hpp +++ /dev/null @@ -1,27 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::reverse_apply`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP -#define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/variadic/reverse_apply/unrolled.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - BOOST_HANA_CONSTEXPR_LAMBDA auto reverse_apply = - [](auto&& f, auto&& ...x) -> decltype(auto) { - return detail::variadic::reverse_apply_unrolled( - static_cast<decltype(f)&&>(f), - static_cast<decltype(x)&&>(x)... - ); - }; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/flat.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/flat.hpp deleted file mode 100644 index 09bc818e6b..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/flat.hpp +++ /dev/null @@ -1,41 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::reverse_apply_flat`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP -#define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/variadic/at.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - template <int ...i, typename F, typename ...X> - constexpr decltype(auto) - reverse_apply_flat_helper(std::integer_sequence<int, i...>, F&& f, X&& ...x) - { - return static_cast<F&&>(f)( - detail::variadic::at<sizeof...(x) - i - 1>( - static_cast<X&&>(x)... - )... - ); - } - - template <typename F, typename ...X> - constexpr decltype(auto) reverse_apply_flat(F&& f, X&& ...x) { - return reverse_apply_flat_helper( - std::make_integer_sequence<int, sizeof...(x)>{}, - static_cast<F&&>(f), - static_cast<X&&>(x)... - ); - } -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_FLAT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/unrolled.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/unrolled.hpp deleted file mode 100644 index e6bf3d0c55..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/reverse_apply/unrolled.hpp +++ /dev/null @@ -1,87 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::reverse_apply_unrolled`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP -#define BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/functional/reverse_partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - struct reverse_apply_unrolled_impl { - template <typename F> - constexpr decltype(auto) operator()(F&& f) const { - return static_cast<F&&>(f)(); - } - - template <typename F, typename X1> - constexpr decltype(auto) operator()(F&& f, X1&& x1) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1) - ); - } - - template <typename F, typename X1, typename X2> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2) const { - return static_cast<F&&>(f)( - static_cast<X2&&>(x2), - static_cast<X1&&>(x1) - ); - } - - template <typename F, typename X1, typename X2, typename X3> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3) const { - return static_cast<F&&>(f)( - static_cast<X3&&>(x3), - static_cast<X2&&>(x2), - static_cast<X1&&>(x1) - ); - } - - template <typename F, typename X1, typename X2, typename X3, typename X4> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4) const { - return static_cast<F&&>(f)( - static_cast<X4&&>(x4), - static_cast<X3&&>(x3), - static_cast<X2&&>(x2), - static_cast<X1&&>(x1) - ); - } - - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5) const { - return static_cast<F&&>(f)( - static_cast<X5&&>(x5), - static_cast<X4&&>(x4), - static_cast<X3&&>(x3), - static_cast<X2&&>(x2), - static_cast<X1&&>(x1) - ); - } - - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename ...Xn> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, Xn&& ...xn) const { - return (*this)(hana::reverse_partial( - static_cast<F&&>(f) - , static_cast<X6&&>(x6) - , static_cast<X5&&>(x5) - , static_cast<X4&&>(x4) - , static_cast<X3&&>(x3) - , static_cast<X2&&>(x2) - , static_cast<X1&&>(x1) - ), static_cast<Xn&&>(xn)...); - } - }; - - constexpr reverse_apply_unrolled_impl reverse_apply_unrolled{}; - -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_REVERSE_APPLY_UNROLLED_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/split_at.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/split_at.hpp deleted file mode 100644 index c068c1bcb9..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/split_at.hpp +++ /dev/null @@ -1,153 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::split_at`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP -#define BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/functional/reverse_partial.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - template <std::size_t n> - struct split_at_t { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7, X8&& x8, Xs&& ...xs) const { - return split_at_t<n - 8>{}( - hana::partial(static_cast<F&&>(f), - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3), - static_cast<X4&&>(x4), - static_cast<X5&&>(x5), - static_cast<X6&&>(x6), - static_cast<X7&&>(x7), - static_cast<X8&&>(x8) - ), - static_cast<Xs&&>(xs)... - ); - } - }; - - template <> - struct split_at_t<0> { - template <typename F, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const { - return static_cast<F&&>(f)()(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<1> { - template <typename F, typename X1, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<2> { - template <typename F, typename X1, typename X2, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<3> { - template <typename F, typename X1, typename X2, typename X3, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<4> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3), - static_cast<X4&&>(x4) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<5> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3), - static_cast<X4&&>(x4), - static_cast<X5&&>(x5) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<6> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3), - static_cast<X4&&>(x4), - static_cast<X5&&>(x5), - static_cast<X6&&>(x6) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <> - struct split_at_t<7> { - template <typename F, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, X1&& x1, X2&& x2, X3&& x3, X4&& x4, X5&& x5, X6&& x6, X7&& x7, Xs&& ...xs) const { - return static_cast<F&&>(f)( - static_cast<X1&&>(x1), - static_cast<X2&&>(x2), - static_cast<X3&&>(x3), - static_cast<X4&&>(x4), - static_cast<X5&&>(x5), - static_cast<X6&&>(x6), - static_cast<X7&&>(x7) - )(static_cast<Xs&&>(xs)...); - } - }; - - template <std::size_t n> - struct _makesplit_at_t { - template <typename ...Xs> - constexpr decltype(auto) operator()(Xs&& ...xs) const { - return hana::reverse_partial(split_at_t<n>{}, - static_cast<Xs&&>(xs)...); - } - }; - - template <std::size_t n> - constexpr _makesplit_at_t<n> split_at{}; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_SPLIT_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/variadic/take.hpp b/contrib/restricted/boost/boost/hana/detail/variadic/take.hpp deleted file mode 100644 index 4d97a5b853..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/variadic/take.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::variadic::take`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP -#define BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/variadic/split_at.hpp> -#include <boost/hana/functional/always.hpp> -#include <boost/hana/functional/reverse_partial.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { namespace variadic { - struct take_impl2 { - template <typename F, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const { - return static_cast<F&&>(f)(static_cast<Xs&&>(xs)...); - } - }; - - struct take_impl1 { - template <typename ...Xs> - constexpr auto operator()(Xs&& ...xs) const { - return hana::always( - reverse_partial(take_impl2{}, - static_cast<Xs&&>(xs)...) - ); - } - }; - - template <std::size_t n> - struct take_t { - template <typename ...Xs> - constexpr decltype(auto) operator()(Xs&& ...xs) const { - return variadic::split_at<n>(static_cast<Xs&&>(xs)...)(take_impl1{}); - } - }; - - template <std::size_t n> - constexpr take_t<n> take{}; -}} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VARIADIC_TAKE_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/void_t.hpp b/contrib/restricted/boost/boost/hana/detail/void_t.hpp deleted file mode 100644 index 9eedd11441..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/void_t.hpp +++ /dev/null @@ -1,21 +0,0 @@ -/*! -@file -Defines an equivalent to the proposed `std::void_t`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_VOID_T_HPP -#define BOOST_HANA_DETAIL_VOID_T_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - template <typename ...> - using void_t = void; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_VOID_T_HPP diff --git a/contrib/restricted/boost/boost/hana/detail/wrong.hpp b/contrib/restricted/boost/boost/hana/detail/wrong.hpp deleted file mode 100644 index ce5544fcdf..0000000000 --- a/contrib/restricted/boost/boost/hana/detail/wrong.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines `boost::hana::detail::wrong`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DETAIL_WRONG_HPP -#define BOOST_HANA_DETAIL_WRONG_HPP - -#include <boost/hana/config.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace detail { - //! @ingroup group-detail - //! Equivalent to a type-dependent `std::false_type`. - //! - //! This is useful for making a static assertion that would otherwise - //! always fire up dependent on some template parameters. - //! - //! - //! Example - //! ------- - //! @include example/detail/wrong.cpp - template <typename ...> - struct wrong : std::false_type { }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DETAIL_WRONG_HPP diff --git a/contrib/restricted/boost/boost/hana/difference.hpp b/contrib/restricted/boost/boost/hana/difference.hpp deleted file mode 100644 index d2e2897d6e..0000000000 --- a/contrib/restricted/boost/boost/hana/difference.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*! -@file -Defines `boost::hana::difference`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DIFFERENCE_HPP -#define BOOST_HANA_DIFFERENCE_HPP - -#include <boost/hana/fwd/difference.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/erase_key.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto difference_t::operator()(Xs&& xs, Ys&& ys) const { - using S = typename hana::tag_of<Xs>::type; - using Difference = BOOST_HANA_DISPATCH_IF(difference_impl<S>, - true - ); - - return Difference::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename S, bool condition> - struct difference_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DIFFERENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/div.hpp b/contrib/restricted/boost/boost/hana/div.hpp deleted file mode 100644 index 5b75ef10be..0000000000 --- a/contrib/restricted/boost/boost/hana/div.hpp +++ /dev/null @@ -1,107 +0,0 @@ -/*! -@file -Defines `boost::hana::div`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DIV_HPP -#define BOOST_HANA_DIV_HPP - -#include <boost/hana/fwd/div.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/euclidean_ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/value.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) div_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Div = BOOST_HANA_DISPATCH_IF(decltype(div_impl<T, U>{}), - hana::EuclideanRing<T>::value && - hana::EuclideanRing<U>::value && - !is_default<div_impl<T, U>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::EuclideanRing<T>::value, - "hana::div(x, y) requires 'x' to be an EuclideanRing"); - - static_assert(hana::EuclideanRing<U>::value, - "hana::div(x, y) requires 'y' to be an EuclideanRing"); - - static_assert(!is_default<div_impl<T, U>>::value, - "hana::div(x, y) requires 'x' and 'y' to be embeddable " - "in a common EuclideanRing"); - #endif - - return Div::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct div_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - // Cross-type overload - template <typename T, typename U> - struct div_impl<T, U, when< - detail::has_nontrivial_common_embedding<EuclideanRing, T, U>::value - >> { - using C = typename common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::div(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for integral data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct div_impl<T, T, when<std::is_integral<T>::value && - !std::is_same<T, bool>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) / static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over an EuclideanRing - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C, typename X, typename Y> - struct constant_from_div { - static constexpr auto value = hana::div(hana::value<X>(), hana::value<Y>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct div_impl<C, C, when< - hana::Constant<C>::value && - EuclideanRing<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const&, Y const&) - { return hana::to<C>(detail::constant_from_div<C, X, Y>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DIV_HPP diff --git a/contrib/restricted/boost/boost/hana/drop_back.hpp b/contrib/restricted/boost/boost/hana/drop_back.hpp deleted file mode 100644 index 0e5837584a..0000000000 --- a/contrib/restricted/boost/boost/hana/drop_back.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::drop_back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DROP_BACK_HPP -#define BOOST_HANA_DROP_BACK_HPP - -#include <boost/hana/fwd/drop_back.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto drop_back_t::operator()(Xs&& xs, N const& n) const { - using S = typename hana::tag_of<Xs>::type; - using DropBack = BOOST_HANA_DISPATCH_IF(drop_back_impl<S>, - hana::Sequence<S>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::drop_back(xs, n) requires 'xs' to be a Sequence"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::drop_back(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - static_assert(N::value >= 0, - "hana::drop_back(xs, n) requires 'n' to be non-negative"); - - return DropBack::apply(static_cast<Xs&&>(xs), n); - } - - template <typename Xs> - constexpr auto drop_back_t::operator()(Xs&& xs) const { - return (*this)(static_cast<Xs&&>(xs), hana::size_c<1>); - } - //! @endcond - - template <typename S, bool condition> - struct drop_back_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...n> - static constexpr auto drop_back_helper(Xs&& xs, std::index_sequence<n...>) { - return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_back_helper(static_cast<Xs&&>(xs), - std::make_index_sequence<(n > len ? 0 : len - n)>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DROP_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/drop_front.hpp b/contrib/restricted/boost/boost/hana/drop_front.hpp deleted file mode 100644 index 2fa5ade108..0000000000 --- a/contrib/restricted/boost/boost/hana/drop_front.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Defines `boost::hana::drop_front`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DROP_FRONT_HPP -#define BOOST_HANA_DROP_FRONT_HPP - -#include <boost/hana/fwd/drop_front.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto drop_front_t::operator()(Xs&& xs, N const& n) const { - using It = typename hana::tag_of<Xs>::type; - using DropFront = BOOST_HANA_DISPATCH_IF(drop_front_impl<It>, - hana::Iterable<It>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::drop_front(xs, n) requires 'xs' to be an Iterable"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::drop_front(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - return DropFront::apply(static_cast<Xs&&>(xs), n); - } - - template <typename Xs> - constexpr auto drop_front_t::operator()(Xs&& xs) const { - return (*this)(static_cast<Xs&&>(xs), hana::size_t<1>{}); - } - //! @endcond - - template <typename It, bool condition> - struct drop_front_impl<It, when<condition>> : default_ { - template <typename Xs, typename N> - static constexpr auto apply(Xs&&, N const&) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DROP_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/drop_front_exactly.hpp b/contrib/restricted/boost/boost/hana/drop_front_exactly.hpp deleted file mode 100644 index a6af69115d..0000000000 --- a/contrib/restricted/boost/boost/hana/drop_front_exactly.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Defines `boost::hana::drop_front_exactly`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DROP_FRONT_EXACTLY_HPP -#define BOOST_HANA_DROP_FRONT_EXACTLY_HPP - -#include <boost/hana/fwd/drop_front_exactly.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/is_empty.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto drop_front_exactly_t::operator()(Xs&& xs, N const& n) const { - using It = typename hana::tag_of<Xs>::type; - using DropFrontExactly = BOOST_HANA_DISPATCH_IF(drop_front_exactly_impl<It>, - hana::Iterable<It>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::drop_front_exactly(xs, n) requires 'xs' to be an Iterable"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::drop_front_exactly(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - static_assert(N::value >= 0, - "hana::drop_front_exactly(xs, n) requires 'n' to be non-negative"); - - return DropFrontExactly::apply(static_cast<Xs&&>(xs), n); - } - - template <typename Xs> - constexpr auto drop_front_exactly_t::operator()(Xs&& xs) const { - return (*this)(static_cast<Xs&&>(xs), hana::size_c<1>); - } - //! @endcond - - namespace detail { - template <typename Xs, typename N> - constexpr void check_dfe_overflow(Xs const& xs, N const&, hana::true_) { - constexpr bool n_overflew_length = decltype( - hana::is_empty(hana::drop_front(xs, hana::size_c<N::value - 1>)) - )::value; - static_assert(!n_overflew_length, - "hana::drop_front_exactly(xs, n) requires 'n' to be less than or " - "equal to the number of elements in 'xs'"); - } - - template <typename Xs, typename N> - constexpr void check_dfe_overflow(Xs const&, N const&, hana::false_) { } - } - - template <typename It, bool condition> - struct drop_front_exactly_impl<It, when<condition>> : default_ { - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const& n) { - auto result = hana::drop_front(static_cast<Xs&&>(xs), n); - constexpr bool check_for_overflow = - decltype(hana::is_empty(result))::value && N::value != 0; - - detail::check_dfe_overflow(xs, n, hana::bool_c<check_for_overflow>); - - return result; // NRVO applied - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DROP_FRONT_EXACTLY_HPP diff --git a/contrib/restricted/boost/boost/hana/drop_while.hpp b/contrib/restricted/boost/boost/hana/drop_while.hpp deleted file mode 100644 index b1f921b1d8..0000000000 --- a/contrib/restricted/boost/boost/hana/drop_while.hpp +++ /dev/null @@ -1,93 +0,0 @@ -/*! -@file -Defines `boost::hana::drop_while`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DROP_WHILE_HPP -#define BOOST_HANA_DROP_WHILE_HPP - -#include <boost/hana/fwd/drop_while.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/first_unsatisfied_index.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/eval_if.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/is_empty.hpp> -#include <boost/hana/lazy.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto drop_while_t::operator()(Xs&& xs, Pred&& pred) const { - using It = typename hana::tag_of<Xs>::type; - using DropWhile = BOOST_HANA_DISPATCH_IF(drop_while_impl<It>, - hana::Iterable<It>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::drop_while(xs, pred) requires 'xs' to be an Iterable"); - #endif - - return DropWhile::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - namespace iterable_detail { - struct drop_while_helper { - struct next { - template <typename Xs, typename Pred> - constexpr decltype(auto) operator()(Xs&& xs, Pred&& pred) const { - return hana::drop_while( - hana::drop_front(static_cast<Xs&&>(xs)), - static_cast<Pred&&>(pred) - ); - } - }; - - template <typename Xs, typename Pred> - constexpr decltype(auto) operator()(Xs&& xs, Pred&& pred) const { - return hana::eval_if(pred(hana::front(xs)), - hana::make_lazy(next{})(xs, pred), - hana::make_lazy(xs) - ); - } - }; - } - - template <typename It, bool condition> - struct drop_while_impl<It, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::eval_if(hana::is_empty(xs), - hana::make_lazy(xs), - hana::make_lazy(iterable_detail::drop_while_helper{})( - xs, static_cast<Pred&&>(pred)) - ); - } - }; - - template <typename S> - struct drop_while_impl<S, when<hana::Foldable<S>::value>> { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&&) { - using FirstUnsatisfied = decltype( - hana::unpack(static_cast<Xs&&>(xs), - detail::first_unsatisfied_index<Pred&&>{}) - ); - return hana::drop_front(static_cast<Xs&&>(xs), - FirstUnsatisfied{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DROP_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/duplicate.hpp b/contrib/restricted/boost/boost/hana/duplicate.hpp deleted file mode 100644 index 783ae05fa0..0000000000 --- a/contrib/restricted/boost/boost/hana/duplicate.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::duplicate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_DUPLICATE_HPP -#define BOOST_HANA_DUPLICATE_HPP - -#include <boost/hana/fwd/duplicate.hpp> - -#include <boost/hana/concept/comonad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/extend.hpp> -#include <boost/hana/functional/id.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename W_> - constexpr decltype(auto) duplicate_t::operator()(W_&& w) const { - using W = typename hana::tag_of<W_>::type; - using Duplicate = BOOST_HANA_DISPATCH_IF(duplicate_impl<W>, - hana::Comonad<W>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Comonad<W>::value, - "hana::duplicate(w) requires 'w' to be a Comonad"); - #endif - - return Duplicate::apply(static_cast<W_&&>(w)); - } - //! @endcond - - template <typename W, bool condition> - struct duplicate_impl<W, when<condition>> : default_ { - template <typename X> - static constexpr decltype(auto) apply(X&& x) - { return hana::extend(static_cast<X&&>(x), hana::id); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_DUPLICATE_HPP diff --git a/contrib/restricted/boost/boost/hana/empty.hpp b/contrib/restricted/boost/boost/hana/empty.hpp deleted file mode 100644 index 8cb97a3ebc..0000000000 --- a/contrib/restricted/boost/boost/hana/empty.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Defines `boost::hana::empty`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EMPTY_HPP -#define BOOST_HANA_EMPTY_HPP - -#include <boost/hana/fwd/empty.hpp> - -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct empty_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::empty<M>() requires 'M' to be a MonadPlus"); - #endif - - constexpr auto operator()() const { - using Empty = BOOST_HANA_DISPATCH_IF(empty_impl<M>, - hana::MonadPlus<M>::value - ); - - return Empty::apply(); - } - }; - - template <typename M, bool condition> - struct empty_impl<M, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S> - struct empty_impl<S, when<Sequence<S>::value>> { - static constexpr auto apply() { - return hana::make<S>(); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EMPTY_HPP diff --git a/contrib/restricted/boost/boost/hana/equal.hpp b/contrib/restricted/boost/boost/hana/equal.hpp deleted file mode 100644 index 1fa5e8bbe1..0000000000 --- a/contrib/restricted/boost/boost/hana/equal.hpp +++ /dev/null @@ -1,203 +0,0 @@ -/*! -@file -Defines `boost::hana::equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EQUAL_HPP -#define BOOST_HANA_EQUAL_HPP - -#include <boost/hana/fwd/equal.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/all_of.hpp> -#include <boost/hana/and.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/comparable.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/product.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/concepts.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_to.hpp> // required by fwd decl -#include <boost/hana/first.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/value.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr auto equal_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Equal = equal_impl<T, U>; - return Equal::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct equal_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr auto apply(X const&, Y const&) { - // Delay the static_assert by ensuring T_ is dependent. - using T_ = typename hana::tag_of<X>::type; - static_assert(!hana::is_convertible<T_, U>::value && - !hana::is_convertible<U, T_>::value, - "No default implementation of hana::equal is provided for related " - "types that can't be safely embedded into a common type, because " - "those are most likely programming errors. If this is really what " - "you want, you can manually convert both objects to a common " - "Comparable type before performing the comparison. If you think " - "you have made your types Comparable but you see this, perhaps you " - "forgot to define some of the necessary methods for an automatic " - "model of Comparable to kick in. A possible culprit is defining " - "'operator==' but not 'operator!='."); - - return hana::false_c; - } - }; - - // Cross-type overload - template <typename T, typename U> - struct equal_impl<T, U, when< - detail::has_nontrivial_common_embedding<Comparable, T, U>::value && - !detail::EqualityComparable<T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr auto apply(X&& x, Y&& y) { - return hana::equal(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for EqualityComparable data types - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U> - struct equal_impl<T, U, when<detail::EqualityComparable<T, U>::value>> { - template <typename X, typename Y> - static constexpr auto apply(X&& x, Y&& y) - { return static_cast<X&&>(x) == static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants wrapping a Comparable - ////////////////////////////////////////////////////////////////////////// - template <typename C> - struct equal_impl<C, C, when< - hana::Constant<C>::value && - Comparable<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr auto apply(X const&, Y const&) { - constexpr auto eq = hana::equal(hana::value<X>(), hana::value<Y>()); - constexpr bool truth_value = hana::if_(eq, true, false); - return hana::bool_<truth_value>{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable for Products - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U> - struct equal_impl<T, U, when<hana::Product<T>::value && hana::Product<U>::value>> { - template <typename X, typename Y> - static constexpr auto apply(X const& x, Y const& y) { - return hana::and_( - hana::equal(hana::first(x), hana::first(y)), - hana::equal(hana::second(x), hana::second(y)) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable for Sequences - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename Xs, typename Ys, std::size_t Length> - struct compare_finite_sequences { - Xs const& xs; - Ys const& ys; - - template <std::size_t i> - constexpr auto apply(hana::false_, hana::true_) const { - return compare_finite_sequences::apply<i+1>( - hana::bool_<i+1 == Length>{}, - hana::if_(hana::equal(hana::at_c<i>(xs), hana::at_c<i>(ys)), - hana::true_c, hana::false_c) - ); - } - - template <std::size_t i> - constexpr auto apply(hana::false_, hana::false_) const - { return hana::false_c; } - - template <std::size_t i, typename Result> - constexpr auto apply(hana::true_, Result r) const - { return r; } - - template <std::size_t i> - constexpr bool apply(hana::false_, bool b) const { - return b && compare_finite_sequences::apply<i+1>( - hana::bool_<i+1 == Length>{}, - hana::if_(hana::equal(hana::at_c<i>(xs), hana::at_c<i>(ys)), - hana::true_c, hana::false_c) - ); - } - }; - } - - template <typename T, typename U> - struct equal_impl<T, U, when<Sequence<T>::value && hana::Sequence<U>::value>> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const& xs, Ys const& ys) { - constexpr std::size_t xs_size = decltype(hana::length(xs))::value; - constexpr std::size_t ys_size = decltype(hana::length(ys))::value; - detail::compare_finite_sequences<Xs, Ys, xs_size> comp{xs, ys}; - return comp.template apply<0>(hana::bool_<xs_size == 0>{}, - hana::bool_<xs_size == ys_size>{}); - } - }; - - namespace detail { - template <typename X, typename Y> - struct compare_struct_members { - X const& x; - Y const& y; - - template <typename Member> - constexpr auto operator()(Member&& member) const { - auto accessor = hana::second(static_cast<Member&&>(member)); - return hana::equal(accessor(x), accessor(y)); - } - }; - } - - template <typename S> - struct equal_impl<S, S, when<hana::Struct<S>::value>> { - template <typename X, typename Y> - static constexpr auto apply(X const& x, Y const& y) { - return hana::all_of(hana::accessors<S>(), - detail::compare_struct_members<X, Y>{x, y}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/erase_key.hpp b/contrib/restricted/boost/boost/hana/erase_key.hpp deleted file mode 100644 index 4a059c9598..0000000000 --- a/contrib/restricted/boost/boost/hana/erase_key.hpp +++ /dev/null @@ -1,37 +0,0 @@ -/*! -@file -Defines `boost::hana::erase_key`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ERASE_KEY_HPP -#define BOOST_HANA_ERASE_KEY_HPP - -#include <boost/hana/fwd/erase_key.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Set, typename ...Args> - constexpr decltype(auto) erase_key_t::operator()(Set&& set, Args&& ...args) const { - return erase_key_impl<typename hana::tag_of<Set>::type>::apply( - static_cast<Set&&>(set), - static_cast<Args&&>(args)... - ); - } - //! @endcond - - template <typename T, bool condition> - struct erase_key_impl<T, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ERASE_KEY_HPP diff --git a/contrib/restricted/boost/boost/hana/eval.hpp b/contrib/restricted/boost/boost/hana/eval.hpp deleted file mode 100644 index 1d8f4aa758..0000000000 --- a/contrib/restricted/boost/boost/hana/eval.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Defines `boost::hana::eval`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EVAL_HPP -#define BOOST_HANA_EVAL_HPP - -#include <boost/hana/fwd/eval.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/wrong.hpp> -#include <boost/hana/functional/id.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Expr> - constexpr decltype(auto) eval_t::operator()(Expr&& expr) const { - return eval_impl<typename hana::tag_of<Expr>::type>::apply( - static_cast<Expr&&>(expr) - ); - } - //! @endcond - - template <typename T, bool condition> - struct eval_impl<T, when<condition>> : default_ { - template <typename Expr> - static constexpr auto eval_helper(Expr&& expr, int) - -> decltype(static_cast<Expr&&>(expr)()) - { return static_cast<Expr&&>(expr)(); } - - template <typename Expr> - static constexpr auto eval_helper(Expr&& expr, long) - -> decltype(static_cast<Expr&&>(expr)(hana::id)) - { return static_cast<Expr&&>(expr)(hana::id); } - - template <typename Expr> - static constexpr auto eval_helper(Expr&&, ...) { - static_assert(detail::wrong<Expr>{}, - "hana::eval(expr) requires the expression to be a hana::lazy, " - "a nullary Callable or a unary Callable that may be " - "called with hana::id"); - } - - template <typename Expr> - static constexpr decltype(auto) apply(Expr&& expr) - { return eval_helper(static_cast<Expr&&>(expr), int{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EVAL_HPP diff --git a/contrib/restricted/boost/boost/hana/eval_if.hpp b/contrib/restricted/boost/boost/hana/eval_if.hpp deleted file mode 100644 index 7d0be870d3..0000000000 --- a/contrib/restricted/boost/boost/hana/eval_if.hpp +++ /dev/null @@ -1,93 +0,0 @@ -/*! -@file -Defines `boost::hana::eval_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EVAL_IF_HPP -#define BOOST_HANA_EVAL_IF_HPP - -#include <boost/hana/fwd/eval_if.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/eval.hpp> -#include <boost/hana/if.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Cond, typename Then, typename Else> - constexpr decltype(auto) eval_if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const { - using Bool = typename hana::tag_of<Cond>::type; - using EvalIf = BOOST_HANA_DISPATCH_IF(eval_if_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::eval_if(cond, then, else) requires 'cond' to be a Logical"); - #endif - - return EvalIf::apply(static_cast<Cond&&>(cond), - static_cast<Then&&>(then_), - static_cast<Else&&>(else_)); - } - //! @endcond - - template <typename L, bool condition> - struct eval_if_impl<L, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename L> - struct eval_if_impl<L, when<std::is_arithmetic<L>::value>> { - template <typename Cond, typename T, typename E> - static constexpr auto apply(Cond const& cond, T&& t, E&& e) { - return cond ? hana::eval(static_cast<T&&>(t)) - : hana::eval(static_cast<E&&>(e)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Logical - ////////////////////////////////////////////////////////////////////////// - template <typename C> - struct eval_if_impl<C, when< - hana::Constant<C>::value && - Logical<typename C::value_type>::value - >> { - template <typename Then, typename Else> - static constexpr decltype(auto) - eval_if_helper(hana::true_, Then&& t, Else&&) - { return hana::eval(static_cast<Then&&>(t)); } - - template <typename Then, typename Else> - static constexpr decltype(auto) - eval_if_helper(hana::false_, Then&&, Else&& e) - { return hana::eval(static_cast<Else&&>(e)); } - - template <typename Cond, typename Then, typename Else> - static constexpr decltype(auto) apply(Cond const&, Then&& t, Else&& e) { - constexpr auto cond = hana::value<Cond>(); - constexpr bool truth_value = hana::if_(cond, true, false); - return eval_if_helper(hana::bool_<truth_value>{}, - static_cast<Then&&>(t), - static_cast<Else&&>(e)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EVAL_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/experimental/printable.hpp b/contrib/restricted/boost/boost/hana/experimental/printable.hpp deleted file mode 100644 index e24a3426ea..0000000000 --- a/contrib/restricted/boost/boost/hana/experimental/printable.hpp +++ /dev/null @@ -1,257 +0,0 @@ -/* -@file -Defines `boost::hana::experimental::print`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP -#define BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/product.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/for_each.hpp> -#include <boost/hana/intersperse.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/transform.hpp> -#include <boost/hana/tuple.hpp> - -// models for different containers -#include <boost/hana/fwd/map.hpp> -#include <boost/hana/fwd/optional.hpp> -#include <boost/hana/fwd/set.hpp> -#include <boost/hana/fwd/string.hpp> -#include <boost/hana/fwd/type.hpp> - -#include <boost/core/demangle.hpp> - -#include <iostream> -#include <regex> -#include <sstream> -#include <string> -#include <typeinfo> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace experimental { - template <typename T> - struct Printable; - - //! @cond - template <typename T, typename = void> - struct print_impl : print_impl<T, hana::when<true>> { }; - - template <typename T, bool condition> - struct print_impl<T, hana::when<condition>> : hana::default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - //! @endcond - - //! @ingroup group-experimental - //! Returns a string representation of the given object. - //! - //! This function is defined for most containers provided by Hana, and - //! also for objects that define an `operator<<` that can be used with - //! a `std::basic_ostream`. It can recursively print containers within - //! containers, but do not expect any kind of proper indentation. - //! - //! This function requires (the rest of) Boost to be available on the - //! system. It also requires RTTI to be enabled. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto print = [](auto const& x) -> std::string { - return tag-dispatched; - }; -#else - struct print_t { - template <typename T> - std::string operator()(T const& t) const { - using Tag = typename hana::tag_of<T>::type; - using Print = BOOST_HANA_DISPATCH_IF(print_impl<Tag>, - hana::experimental::Printable<Tag>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::experimental::Printable<Tag>::value, - "hana::experimental::print(t) requires 't' to be Printable"); - #endif - - return Print::apply(t); - } - }; - - constexpr print_t print{}; -#endif - - // Define the `Printable` concept - template <typename T> - struct Printable { - using Tag = typename hana::tag_of<T>::type; - static constexpr bool value = !hana::is_default<print_impl<Tag>>::value; - }; - - namespace print_detail { - std::string strip_type_junk(std::string const& str) { - return std::regex_replace(str, std::regex("^([a-z_]+::)*([a-z_]*)_t<"), "$2<"); - } - } - - // model for Sequences - template <typename S> - struct print_impl<S, hana::when<hana::Sequence<S>::value>> { - template <typename Xs> - static std::string apply(Xs const& xs) { - std::string result = "("; - auto comma_separated = hana::intersperse(xs, ", "); - hana::for_each(comma_separated, [&result](auto const& x) { - result += hana::experimental::print(x); - }); - result += ")"; - return result; - } - }; - - // model for OutputStreamable types - //! @cond - template <typename S> - struct print_impl<S, hana::when_valid<decltype( - std::declval<std::ostringstream&>() << std::declval<S const&>() - )>> { - template <typename T> - static std::string apply(T const& t) { - std::ostringstream os; - os << t; - return os.str(); - } - }; - //! @endcond - - // model for hana::optional - template <> - struct print_impl<hana::optional_tag> { - template <typename O> - static std::string apply(O const& optional) { - return hana::maybe("nothing", - [](auto const& x) { - return "just(" + hana::experimental::print(x) + ")"; - }, optional); - } - }; - - // model for hana::maps - template <> - struct print_impl<hana::map_tag> { - template <typename M> - static std::string apply(M const& map) { - std::string result = "{"; - auto pairs = hana::transform(hana::to_tuple(map), - [](auto const& pair) { - return hana::experimental::print(hana::first(pair)) - + " => " - + hana::experimental::print(hana::second(pair)); - }); - auto comma_separated = hana::intersperse(pairs, ", "); - hana::for_each(comma_separated, [&result](auto const& element) { - result += element; - }); - result += "}"; - return result; - } - }; - - // model for hana::metafunctions - template <template <typename ...> class F> - struct print_impl<hana::metafunction_t<F>> { - template <typename T> - static std::string apply(T const&) { - return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); - } - }; - - // model for hana::metafunction_classes - template <typename F> - struct print_impl<hana::metafunction_class_t<F>> { - template <typename T> - static std::string apply(T const&) { - return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); - } - }; - - // model for Constants holding a `Printable` - template <typename C> - struct print_impl<C, hana::when< - hana::Constant<C>::value && - Printable<typename C::value_type>::value - >> { - template <typename T> - static std::string apply(T const&) { - constexpr auto value = hana::value<T>(); - return hana::experimental::print(value); - } - }; - - // model for Products - template <typename P> - struct print_impl<P, hana::when<hana::Product<P>::value>> { - template <typename T> - static std::string apply(T const& t) { - return '(' + hana::experimental::print(hana::first(t)) - + ", " - + hana::experimental::print(hana::second(t)) + ')'; - } - }; - - // model for hana::strings - template <> - struct print_impl<hana::string_tag> { - template <typename S> - static std::string apply(S const& s) { - return '"' + std::string{hana::to<char const*>(s)} + '"'; - } - }; - - // model for hana::sets - template <> - struct print_impl<hana::set_tag> { - template <typename S> - static std::string apply(S const& set) { - std::string result = "{"; - auto as_tuple = hana::transform(hana::to_tuple(set), - hana::experimental::print); - auto comma_separated = hana::intersperse(as_tuple, ", "); - hana::for_each(comma_separated, [&result](auto const& element) { - result += element; - }); - result += "}"; - return result; - } - }; - - // model for hana::templates - template <template <typename ...> class F> - struct print_impl<template_t<F>> { - template <typename T> - static std::string apply(T const&) { - return print_detail::strip_type_junk(boost::core::demangle(typeid(T).name())); - } - }; - - // model for hana::types - template <> - struct print_impl<hana::type_tag> { - template <typename T> - static std::string apply(T const&) { - using Type = typename T::type; - return "type<" + boost::core::demangle(typeid(Type).name()) + '>'; - } - }; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXPERIMENTAL_PRINTABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/experimental/type_name.hpp b/contrib/restricted/boost/boost/hana/experimental/type_name.hpp deleted file mode 100644 index f3db176178..0000000000 --- a/contrib/restricted/boost/boost/hana/experimental/type_name.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/* -@file -Defines `boost::hana::experimental::type_name`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP -#define BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/string.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN namespace experimental { - namespace detail { - struct cstring { - char const* ptr; - std::size_t length; - }; - - // Note: We substract the null terminator from the string sizes below. - template <typename T> - constexpr cstring type_name_impl2() { - - #if defined(__clang__) - constexpr char const* pretty_function = __PRETTY_FUNCTION__; - constexpr std::size_t total_size = sizeof(__PRETTY_FUNCTION__) - 1; - constexpr std::size_t prefix_size = sizeof("boost::hana::experimental::detail::cstring boost::hana::experimental::detail::type_name_impl2() [T = ") - 1; - constexpr std::size_t suffix_size = sizeof("]") - 1; - #else - #error "No support for this compiler." - #endif - - return {pretty_function + prefix_size, total_size - prefix_size - suffix_size}; - } - - template <typename T, std::size_t ...i> - auto type_name_impl1(std::index_sequence<i...>) { - constexpr auto name = detail::type_name_impl2<T>(); - return hana::string<*(name.ptr + i)...>{}; - } - } // end namespace detail - - //! @ingroup group-experimental - //! Returns a `hana::string` representing the name of the given type, at - //! compile-time. - //! - //! This only works on Clang (and apparently MSVC, but Hana does not work - //! there as of writing this). Original idea taken from - //! https://github.com/Manu343726/ctti. - template <typename T> - auto type_name() { - constexpr auto name = detail::type_name_impl2<T>(); - return detail::type_name_impl1<T>(std::make_index_sequence<name.length>{}); - } -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXPERIMENTAL_TYPE_NAME_HPP diff --git a/contrib/restricted/boost/boost/hana/experimental/types.hpp b/contrib/restricted/boost/boost/hana/experimental/types.hpp deleted file mode 100644 index be1436a506..0000000000 --- a/contrib/restricted/boost/boost/hana/experimental/types.hpp +++ /dev/null @@ -1,158 +0,0 @@ -/*! -@file -Defines `boost::hana::experimental::types`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXPERIMENTAL_TYPES_HPP -#define BOOST_HANA_EXPERIMENTAL_TYPES_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/metafunction.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/any_of.hpp> -#include <boost/hana/detail/type_at.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/contains.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/transform.hpp> -#include <boost/hana/fwd/unpack.hpp> -#include <boost/hana/type.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace experimental { - //! @ingroup group-experimental - //! Container optimized for holding types. - //! - //! It is often useful to manipulate a sequence that contains types - //! only, without any associated runtime value. This container allows - //! storing and manipulating pure types in a much more compile-time - //! efficient manner than using `hana::tuple`, which must assume that - //! its contents might have runtime values. - template <typename ...T> - struct types; - - struct types_tag; - - template <typename ...T> - struct types { }; - } // end namespace experimental - - template <typename ...T> - struct tag_of<experimental::types<T...>> { - using type = experimental::types_tag; - }; - - // Foldable - template <> - struct unpack_impl<hana::experimental::types_tag> { - template <typename ...T, typename F, typename = typename std::enable_if< - !hana::Metafunction<F>::value - >::type> - static constexpr decltype(auto) apply(hana::experimental::types<T...> const&, F&& f) { - return static_cast<F&&>(f)(hana::type<T>{}...); - } - - template <typename ...T, typename F, typename = typename std::enable_if< - hana::Metafunction<F>::value - >::type> - static constexpr hana::type<typename F::template apply<T...>::type> - apply(hana::experimental::types<T...> const&, F const&) { return {}; } - }; - - // Functor - template <> - struct transform_impl<hana::experimental::types_tag> { - template <typename ...T, typename F, typename = typename std::enable_if< - !hana::Metafunction<F>::value - >::type> - static constexpr auto apply(hana::experimental::types<T...> const&, F&& f) - -> hana::experimental::types<typename decltype(+f(hana::type<T>{}))::type...> - { return {}; } - - template <typename ...T, typename F, typename = typename std::enable_if< - hana::Metafunction<F>::value - >::type> - static constexpr hana::experimental::types<typename F::template apply<T>::type...> - apply(hana::experimental::types<T...> const&, F const&) { return {}; } - }; - - // Iterable - template <> - struct at_impl<hana::experimental::types_tag> { - template <typename ...T, typename N> - static constexpr auto - apply(hana::experimental::types<T...> const&, N const&) { - using Nth = typename detail::type_at<N::value, T...>::type; - return hana::type<Nth>{}; - } - }; - - template <> - struct is_empty_impl<hana::experimental::types_tag> { - template <typename ...T> - static constexpr hana::bool_<sizeof...(T) == 0> - apply(hana::experimental::types<T...> const&) - { return {}; } - }; - - template <> - struct drop_front_impl<hana::experimental::types_tag> { - template <std::size_t n, typename ...T, std::size_t ...i> - static hana::experimental::types<typename detail::type_at<i + n, T...>::type...> - helper(std::index_sequence<i...>); - - template <typename ...T, typename N> - static constexpr auto - apply(hana::experimental::types<T...> const&, N const&) { - constexpr std::size_t n = N::value > sizeof...(T) ? sizeof...(T) : N::value; - using Indices = std::make_index_sequence<sizeof...(T) - n>; - return decltype(helper<n, T...>(Indices{})){}; - } - }; - - // Searchable - template <> - struct contains_impl<hana::experimental::types_tag> { - template <typename U> - struct is_same_as { - template <typename T> - struct apply { - static constexpr bool value = std::is_same<U, T>::value; - }; - }; - - template <typename ...T, typename U> - static constexpr auto apply(hana::experimental::types<T...> const&, U const&) - -> hana::bool_< - detail::any_of<is_same_as<typename U::type>::template apply, T...>::value - > - { return {}; } - - static constexpr hana::false_ apply(...) { return {}; } - }; - - // Comparable - template <> - struct equal_impl<hana::experimental::types_tag, hana::experimental::types_tag> { - template <typename Types> - static constexpr hana::true_ apply(Types const&, Types const&) - { return {}; } - - template <typename Ts, typename Us> - static constexpr hana::false_ apply(Ts const&, Us const&) - { return {}; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXPERIMENTAL_TYPES_HPP diff --git a/contrib/restricted/boost/boost/hana/experimental/view.hpp b/contrib/restricted/boost/boost/hana/experimental/view.hpp deleted file mode 100644 index cc2f4c606f..0000000000 --- a/contrib/restricted/boost/boost/hana/experimental/view.hpp +++ /dev/null @@ -1,515 +0,0 @@ -/* -@file -Defines experimental views. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXPERIMENTAL_VIEW_HPP -#define BOOST_HANA_EXPERIMENTAL_VIEW_HPP - -#include <boost/hana/and.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/functional/on.hpp> -#include <boost/hana/fwd/ap.hpp> -#include <boost/hana/fwd/concat.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/empty.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/flatten.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/fwd/lift.hpp> -#include <boost/hana/fwd/transform.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/lexicographical_compare.hpp> -#include <boost/hana/range.hpp> -#include <boost/hana/tuple.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -// Pros of views -// - No temporary container created between algorithms -// - Lazy, so only the minimum is required -// -// Cons of views -// - Reference semantics mean possibility for dangling references -// - Lose the ability to move from temporary containers -// - When fetching the members of a view multiple times, no caching is done. -// So for example, `t = transform(xs, f); at_c<0>(t); at_c<0>(t)` will -// compute `f(at_c<0>(xs))` twice. -// - push_back creates a joint_view and a single_view. The single_view holds -// the value as a member. When doing multiple push_backs, we end up with a -// joint_view<xxx, joint_view<single_view<T>, joint_view<single_view<T>, ....>>> -// which contains a reference to `xxx` and all the `T`s by value. Such a -// "view" is not cheap to copy, which is inconsistent with the usual -// expectations about views. - -BOOST_HANA_NAMESPACE_BEGIN - -namespace experimental { - struct view_tag; - - namespace detail { - template <typename Sequence> - struct is_view { - static constexpr bool value = false; - }; - - template <typename Sequence> - using view_storage = typename std::conditional< - detail::is_view<Sequence>::value, Sequence, Sequence& - >::type; - } - - ////////////////////////////////////////////////////////////////////////// - // sliced_view - ////////////////////////////////////////////////////////////////////////// - template <typename Sequence, std::size_t ...indices> - struct sliced_view_t { - detail::view_storage<Sequence> sequence_; - using hana_tag = view_tag; - }; - - template <typename Sequence, typename Indices> - constexpr auto sliced(Sequence& sequence, Indices const& indices) { - return hana::unpack(indices, [&](auto ...i) { - return sliced_view_t<Sequence, decltype(i)::value...>{sequence}; - }); - } - - namespace detail { - template <typename Sequence, std::size_t ...i> - struct is_view<sliced_view_t<Sequence, i...>> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // transformed_view - ////////////////////////////////////////////////////////////////////////// - template <typename Sequence, typename F> - struct transformed_view_t { - detail::view_storage<Sequence> sequence_; - F f_; - using hana_tag = view_tag; - }; - - template <typename Sequence, typename F> - constexpr transformed_view_t<Sequence, typename hana::detail::decay<F>::type> - transformed(Sequence& sequence, F&& f) { - return {sequence, static_cast<F&&>(f)}; - } - - namespace detail { - template <typename Sequence, typename F> - struct is_view<transformed_view_t<Sequence, F>> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // filtered_view - ////////////////////////////////////////////////////////////////////////// -#if 0 - template <typename Sequence, typename Pred> - using filtered_view_t = sliced_view_t<Sequence, detail::filtered_indices<...>>; - - template <typename Sequence, typename Pred> - constexpr filtered_view_t<Sequence, Pred> filtered(Sequence& sequence, Pred&& pred) { - return {sequence}; - } -#endif - - ////////////////////////////////////////////////////////////////////////// - // joined_view - ////////////////////////////////////////////////////////////////////////// - template <typename Sequence1, typename Sequence2> - struct joined_view_t { - detail::view_storage<Sequence1> sequence1_; - detail::view_storage<Sequence2> sequence2_; - using hana_tag = view_tag; - }; - - struct make_joined_view_t { - template <typename Sequence1, typename Sequence2> - constexpr joined_view_t<Sequence1, Sequence2> operator()(Sequence1& s1, Sequence2& s2) const { - return {s1, s2}; - } - }; - constexpr make_joined_view_t joined{}; - - namespace detail { - template <typename Sequence1, typename Sequence2> - struct is_view<joined_view_t<Sequence1, Sequence2>> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // single_view - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct single_view_t { - T value_; - using hana_tag = view_tag; - }; - - template <typename T> - constexpr single_view_t<typename hana::detail::decay<T>::type> single_view(T&& t) { - return {static_cast<T&&>(t)}; - } - - namespace detail { - template <typename T> - struct is_view<single_view_t<T>> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // empty_view - ////////////////////////////////////////////////////////////////////////// - struct empty_view_t { - using hana_tag = view_tag; - }; - - constexpr empty_view_t empty_view() { - return {}; - } - - namespace detail { - template <> - struct is_view<empty_view_t> { - static constexpr bool value = true; - }; - } -} // end namespace experimental - -////////////////////////////////////////////////////////////////////////// -// Foldable -////////////////////////////////////////////////////////////////////////// -template <> -struct unpack_impl<experimental::view_tag> { - // sliced_view - template <typename Sequence, std::size_t ...i, typename F> - static constexpr decltype(auto) - apply(experimental::sliced_view_t<Sequence, i...> view, F&& f) { - (void)view; // Remove spurious unused variable warning with GCC - return static_cast<F&&>(f)(hana::at_c<i>(view.sequence_)...); - } - - // transformed_view - template <typename Sequence, typename F, typename G> - static constexpr decltype(auto) - apply(experimental::transformed_view_t<Sequence, F> view, G&& g) { - return hana::unpack(view.sequence_, hana::on(static_cast<G&&>(g), view.f_)); - } - - // joined_view - template <typename View, typename F, std::size_t ...i1, std::size_t ...i2> - static constexpr decltype(auto) - unpack_joined(View view, F&& f, std::index_sequence<i1...>, - std::index_sequence<i2...>) - { - (void)view; // Remove spurious unused variable warning with GCC - return static_cast<F&&>(f)(hana::at_c<i1>(view.sequence1_)..., - hana::at_c<i2>(view.sequence2_)...); - } - - template <typename S1, typename S2, typename F> - static constexpr decltype(auto) - apply(experimental::joined_view_t<S1, S2> view, F&& f) { - constexpr auto N1 = decltype(hana::length(view.sequence1_))::value; - constexpr auto N2 = decltype(hana::length(view.sequence2_))::value; - return unpack_joined(view, static_cast<F&&>(f), - std::make_index_sequence<N1>{}, - std::make_index_sequence<N2>{}); - } - - // single_view - template <typename T, typename F> - static constexpr decltype(auto) apply(experimental::single_view_t<T> view, F&& f) { - return static_cast<F&&>(f)(view.value_); - } - - // empty_view - template <typename F> - static constexpr decltype(auto) apply(experimental::empty_view_t, F&& f) { - return static_cast<F&&>(f)(); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Iterable -////////////////////////////////////////////////////////////////////////// -template <> -struct at_impl<experimental::view_tag> { - // sliced_view - template <typename Sequence, std::size_t ...i, typename N> - static constexpr decltype(auto) - apply(experimental::sliced_view_t<Sequence, i...> view, N const&) { - constexpr std::size_t indices[] = {i...}; - constexpr std::size_t n = indices[N::value]; - return hana::at_c<n>(view.sequence_); - } - - // transformed_view - template <typename Sequence, typename F, typename N> - static constexpr decltype(auto) - apply(experimental::transformed_view_t<Sequence, F> view, N const& n) { - return view.f_(hana::at(view.sequence_, n)); - } - - // joined_view - template <std::size_t Left, typename View, typename N> - static constexpr decltype(auto) at_joined_view(View view, N const&, hana::true_) { - return hana::at_c<N::value>(view.sequence1_); - } - - template <std::size_t Left, typename View, typename N> - static constexpr decltype(auto) at_joined_view(View view, N const&, hana::false_) { - return hana::at_c<N::value - Left>(view.sequence2_); - } - - template <typename S1, typename S2, typename N> - static constexpr decltype(auto) - apply(experimental::joined_view_t<S1, S2> view, N const& n) { - constexpr auto Left = decltype(hana::length(view.sequence1_))::value; - return at_joined_view<Left>(view, n, hana::bool_c<(N::value < Left)>); - } - - // single_view - template <typename T, typename N> - static constexpr decltype(auto) apply(experimental::single_view_t<T> view, N const&) { - static_assert(N::value == 0, - "trying to fetch an out-of-bounds element in a hana::single_view"); - return view.value_; - } - - // empty_view - template <typename N> - static constexpr decltype(auto) apply(experimental::empty_view_t, N const&) = delete; -}; - -template <> -struct length_impl<experimental::view_tag> { - // sliced_view - template <typename Sequence, std::size_t ...i> - static constexpr auto - apply(experimental::sliced_view_t<Sequence, i...>) { - return hana::size_c<sizeof...(i)>; - } - - // transformed_view - template <typename Sequence, typename F> - static constexpr auto apply(experimental::transformed_view_t<Sequence, F> view) { - return hana::length(view.sequence_); - } - - // joined_view - template <typename S1, typename S2> - static constexpr auto apply(experimental::joined_view_t<S1, S2> view) { - return hana::size_c< - decltype(hana::length(view.sequence1_))::value + - decltype(hana::length(view.sequence2_))::value - >; - } - - // single_view - template <typename T> - static constexpr auto apply(experimental::single_view_t<T>) { - return hana::size_c<1>; - } - - // empty_view - static constexpr auto apply(experimental::empty_view_t) { - return hana::size_c<0>; - } -}; - -template <> -struct is_empty_impl<experimental::view_tag> { - // sliced_view - template <typename Sequence, std::size_t ...i> - static constexpr auto - apply(experimental::sliced_view_t<Sequence, i...>) { - return hana::bool_c<sizeof...(i) == 0>; - } - - // transformed_view - template <typename Sequence, typename F> - static constexpr auto apply(experimental::transformed_view_t<Sequence, F> view) { - return hana::is_empty(view.sequence_); - } - - // joined_view - template <typename S1, typename S2> - static constexpr auto apply(experimental::joined_view_t<S1, S2> view) { - return hana::and_(hana::is_empty(view.sequence1_), - hana::is_empty(view.sequence2_)); - } - - // single_view - template <typename T> - static constexpr auto apply(experimental::single_view_t<T>) { - return hana::false_c; - } - - // empty_view - static constexpr auto apply(experimental::empty_view_t) { - return hana::true_c; - } -}; - -template <> -struct drop_front_impl<experimental::view_tag> { - template <typename View, typename N> - static constexpr auto apply(View view, N const&) { - constexpr auto n = N::value; - constexpr auto Length = decltype(hana::length(view))::value; - return experimental::sliced(view, hana::range_c<std::size_t, n, Length>); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Functor -////////////////////////////////////////////////////////////////////////// -template <> -struct transform_impl<experimental::view_tag> { - template <typename Sequence, typename F, typename G> - static constexpr auto - apply(experimental::transformed_view_t<Sequence, F> view, G&& g) { - return experimental::transformed(view.sequence_, - hana::compose(static_cast<G&&>(g), view.f_)); - } - - template <typename View, typename F> - static constexpr auto apply(View view, F&& f) { - return experimental::transformed(view, static_cast<F&&>(f)); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Applicative -////////////////////////////////////////////////////////////////////////// -template <> -struct lift_impl<experimental::view_tag> { - template <typename T> - static constexpr auto apply(T&& t) { - return experimental::single_view(static_cast<T&&>(t)); - } -}; - -template <> -struct ap_impl<experimental::view_tag> { - template <typename F, typename X> - static constexpr auto apply(F&& f, X&& x) { - // TODO: Implement cleverly; we most likely need a cartesian_product - // view or something like that. - return hana::ap(hana::to_tuple(f), hana::to_tuple(x)); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Monad -////////////////////////////////////////////////////////////////////////// -template <> -struct flatten_impl<experimental::view_tag> { - template <typename View> - static constexpr auto apply(View view) { - // TODO: Implement a flattened_view instead - return hana::fold_left(view, experimental::empty_view(), - experimental::joined); - } -}; - -////////////////////////////////////////////////////////////////////////// -// MonadPlus -////////////////////////////////////////////////////////////////////////// -template <> -struct concat_impl<experimental::view_tag> { - template <typename View1, typename View2> - static constexpr auto apply(View1 view1, View2 view2) { - return experimental::joined(view1, view2); - } -}; - -template <> -struct empty_impl<experimental::view_tag> { - static constexpr auto apply() { - return experimental::empty_view(); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Comparable -////////////////////////////////////////////////////////////////////////// -template <> -struct equal_impl<experimental::view_tag, experimental::view_tag> { - template <typename View1, typename View2> - static constexpr auto apply(View1 v1, View2 v2) { - // TODO: Use a lexicographical comparison algorithm. - return hana::equal(hana::to_tuple(v1), hana::to_tuple(v2)); - } -}; - -template <typename S> -struct equal_impl<experimental::view_tag, S, hana::when<hana::Sequence<S>::value>> { - template <typename View1, typename Seq> - static constexpr auto apply(View1 v1, Seq const& s) { - // TODO: Use a lexicographical comparison algorithm. - return hana::equal(hana::to_tuple(v1), hana::to_tuple(s)); - } -}; - -template <typename S> -struct equal_impl<S, experimental::view_tag, hana::when<hana::Sequence<S>::value>> { - template <typename Seq, typename View2> - static constexpr auto apply(Seq const& s, View2 v2) { - // TODO: Use a lexicographical comparison algorithm. - return hana::equal(hana::to_tuple(s), hana::to_tuple(v2)); - } -}; - -////////////////////////////////////////////////////////////////////////// -// Orderable -////////////////////////////////////////////////////////////////////////// -template <> -struct less_impl<experimental::view_tag, experimental::view_tag> { - template <typename View1, typename View2> - static constexpr auto apply(View1 v1, View2 v2) { - return hana::lexicographical_compare(v1, v2); - } -}; - -template <typename S> -struct less_impl<experimental::view_tag, S, hana::when<hana::Sequence<S>::value>> { - template <typename View1, typename Seq> - static constexpr auto apply(View1 v1, Seq const& s) { - return hana::lexicographical_compare(v1, s); - } -}; - -template <typename S> -struct less_impl<S, experimental::view_tag, hana::when<hana::Sequence<S>::value>> { - template <typename Seq, typename View2> - static constexpr auto apply(Seq const& s, View2 v2) { - return hana::lexicographical_compare(s, v2); - } -}; - -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXPERIMENTAL_VIEW_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost.hpp b/contrib/restricted/boost/boost/hana/ext/boost.hpp deleted file mode 100644 index aae8d5c27d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost.hpp +++ /dev/null @@ -1,21 +0,0 @@ -/*! -@file -Includes all the adaptors for external Boost libraries. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_HPP -#define BOOST_HANA_EXT_BOOST_HPP - -//! @ingroup group-ext -//! @defgroup group-ext-boost Other Boost adapters -//! Adapters for miscellaneous heterogeneous containers in Boost. - -#include <boost/hana/ext/boost/fusion.hpp> -#include <boost/hana/ext/boost/mpl.hpp> -#include <boost/hana/ext/boost/tuple.hpp> - -#endif // !BOOST_HANA_EXT_BOOST_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion.hpp deleted file mode 100644 index 7f775da9d9..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion.hpp +++ /dev/null @@ -1,22 +0,0 @@ -/*! -@file -Includes all the adaptors for the Boost.Fusion library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_HPP - -//! @ingroup group-ext -//! @defgroup group-ext-fusion Boost.Fusion adapters -//! Adapters for Boost.Fusion containers. - -#include <boost/hana/ext/boost/fusion/deque.hpp> -#include <boost/hana/ext/boost/fusion/list.hpp> -#include <boost/hana/ext/boost/fusion/tuple.hpp> -#include <boost/hana/ext/boost/fusion/vector.hpp> - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion/deque.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion/deque.hpp deleted file mode 100644 index 698638157d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion/deque.hpp +++ /dev/null @@ -1,108 +0,0 @@ -/*! -@file -Adapts `boost::fusion::deque` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP - -#include <boost/hana/at.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/ext/boost/fusion/detail/common.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/length.hpp> - -#include <boost/fusion/container/deque.hpp> -#include <boost/fusion/container/generation/make_deque.hpp> -#include <boost/fusion/support/tag_of.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace fusion { - //! @ingroup group-ext-fusion - //! Adapter for Boost.Fusion deques. - //! - //! - //! Modeled concepts - //! ---------------- - //! A Fusion deque is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of a tuple. - //! - //! @include example/ext/boost/fusion/deque.cpp - template <typename ...T> - struct deque { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace fusion { - struct deque_tag; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename ::boost::fusion::traits::tag_of<T>::type, - ::boost::fusion::traits::tag_of< - ::boost::fusion::deque<> - >::type - >::value - >> { - using type = ext::boost::fusion::deque_tag; - }; - - namespace detail { - template <> - struct is_fusion_sequence<ext::boost::fusion::deque_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Iterable (the rest is in detail/common.hpp) - ////////////////////////////////////////////////////////////////////////// - template <> - struct drop_front_impl<ext::boost::fusion::deque_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<ext::boost::fusion::deque_tag>( - hana::at_c<n + i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<ext::boost::fusion::deque_tag> { - template <typename ...Xs> - static constexpr auto apply(Xs&& ...xs) { - return ::boost::fusion::make_deque(static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_DEQUE_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion/detail/common.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion/detail/common.hpp deleted file mode 100644 index 298d74d93d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion/detail/common.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/*! -@file -Defines common methods for all Boost.Fusion sequences. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/concept/sequence.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <boost/fusion/sequence/intrinsic/at.hpp> -#include <boost/fusion/sequence/intrinsic/empty.hpp> -#include <boost/fusion/sequence/intrinsic/size.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename T> - struct is_fusion_sequence { - static constexpr bool value = false; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <typename S> - struct at_impl<S, when<detail::is_fusion_sequence<S>::value>> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - return boost::fusion::at_c<n>(static_cast<Xs&&>(xs)); - } - }; - - template <typename S> - struct is_empty_impl<S, when<detail::is_fusion_sequence<S>::value>> { - template <typename Xs> - static constexpr auto apply(Xs&& xs) { - using Empty = decltype(boost::fusion::empty(xs)); - return hana::bool_c<Empty::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <typename S> - struct length_impl<S, when<detail::is_fusion_sequence<S>::value>> { - template <typename Xs> - static constexpr auto apply(Xs const&) { - using Size = typename boost::fusion::result_of::size<Xs>::type; - return hana::size_c<Size::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <typename S> - struct Sequence<S, when<detail::is_fusion_sequence<S>::value>> { - static constexpr bool value = true; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_DETAIL_COMMON_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion/list.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion/list.hpp deleted file mode 100644 index 0bdcb23dc5..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion/list.hpp +++ /dev/null @@ -1,111 +0,0 @@ -/*! -@file -Adapts `boost::fusion::list` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/ext/boost/fusion/detail/common.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/length.hpp> - -#include <boost/fusion/algorithm/transformation/pop_front.hpp> -#include <boost/fusion/container/generation/make_list.hpp> -#include <boost/fusion/container/list.hpp> -#include <boost/fusion/container/list/convert.hpp> -#include <boost/fusion/support/tag_of.hpp> -#include <boost/version.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace fusion { - //! @ingroup group-ext-fusion - //! Adapter for Boost.Fusion lists. - //! - //! - //! Modeled concepts - //! ---------------- - //! A Fusion list is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of a tuple. - //! - //! @include example/ext/boost/fusion/list.cpp - template <typename ...T> - struct list { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace fusion { - struct list_tag; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename ::boost::fusion::traits::tag_of<T>::type, - ::boost::fusion::traits::tag_of< - ::boost::fusion::list<> - >::type - >::value - >> { - using type = ext::boost::fusion::list_tag; - }; - - namespace detail { - template <> - struct is_fusion_sequence<ext::boost::fusion::list_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Iterable (the rest is in detail/common.hpp) - ////////////////////////////////////////////////////////////////////////// - template <> - struct drop_front_impl<ext::boost::fusion::list_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<ext::boost::fusion::list_tag>( - hana::at_c<n + i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<ext::boost::fusion::list_tag> { - template <typename ...Xs> - static constexpr auto apply(Xs&& ...xs) { - return ::boost::fusion::make_list(static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_LIST_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion/tuple.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion/tuple.hpp deleted file mode 100644 index cf427e51d3..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion/tuple.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/*! -@file -Adapts `boost::fusion::tuple` for use with Hana. - -In the current version of Boost.Fusion, `boost::fusion::tuple` is basically -an alias to `boost::fusion::vector`, so both data types share the same -implementation in Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/ext/boost/fusion/vector.hpp> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace fusion { - //! @ingroup group-ext-fusion - //! Adapter for Boost.Fusion tuples. - //! - //! - //! Modeled concepts - //! ---------------- - //! A Fusion tuple is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of a tuple. - //! - //! @include example/ext/boost/fusion/tuple.cpp - template <typename ...T> - struct tuple { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace fusion { - // In the current version of Boost.Fusion, `boost::fusion::tuple` is - // basically an alias to `boost::fusion::vector`, hence the alias. - using tuple_tag = vector_tag; - }}} -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/fusion/vector.hpp b/contrib/restricted/boost/boost/hana/ext/boost/fusion/vector.hpp deleted file mode 100644 index 9a2a3a8c5d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/fusion/vector.hpp +++ /dev/null @@ -1,110 +0,0 @@ -/*! -@file -Adapts `boost::fusion::vector` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP -#define BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/ext/boost/fusion/detail/common.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/length.hpp> - -#include <boost/fusion/algorithm/transformation/pop_front.hpp> -#include <boost/fusion/container/generation/make_vector.hpp> -#include <boost/fusion/container/vector.hpp> -#include <boost/fusion/container/vector/convert.hpp> -#include <boost/fusion/support/tag_of.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace fusion { - //! @ingroup group-ext-fusion - //! Adapter for Boost.Fusion vectors. - //! - //! - //! Modeled concepts - //! ---------------- - //! A Fusion vector is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of a tuple. - //! - //! @include example/ext/boost/fusion/vector.cpp - template <typename ...T> - struct vector { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace fusion { - struct vector_tag; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename ::boost::fusion::traits::tag_of<T>::type, - ::boost::fusion::traits::tag_of< - ::boost::fusion::vector<> - >::type - >::value - >> { - using type = ext::boost::fusion::vector_tag; - }; - - namespace detail { - template <> - struct is_fusion_sequence<ext::boost::fusion::vector_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Iterable (the rest is in detail/common.hpp) - ////////////////////////////////////////////////////////////////////////// - template <> - struct drop_front_impl<ext::boost::fusion::vector_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<ext::boost::fusion::vector_tag>( - hana::at_c<n + i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<ext::boost::fusion::vector_tag> { - template <typename ...Xs> - static constexpr auto apply(Xs&& ...xs) { - return ::boost::fusion::make_vector(static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_FUSION_VECTOR_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/mpl.hpp b/contrib/restricted/boost/boost/hana/ext/boost/mpl.hpp deleted file mode 100644 index 2188c83be2..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/mpl.hpp +++ /dev/null @@ -1,21 +0,0 @@ -/*! -@file -Includes all the adaptors for the Boost.MPL library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_MPL_HPP -#define BOOST_HANA_EXT_BOOST_MPL_HPP - -//! @ingroup group-ext -//! @defgroup group-ext-mpl Boost.MPL adapters -//! Adapters for Boost.MPL containers. - -#include <boost/hana/ext/boost/mpl/integral_c.hpp> -#include <boost/hana/ext/boost/mpl/list.hpp> -#include <boost/hana/ext/boost/mpl/vector.hpp> - -#endif // !BOOST_HANA_EXT_BOOST_MPL_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/mpl/integral_c.hpp b/contrib/restricted/boost/boost/hana/ext/boost/mpl/integral_c.hpp deleted file mode 100644 index 68ddd18486..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/mpl/integral_c.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*! -@file -Adapts Boost.MPL IntegralConstants for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP -#define BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/core/to.hpp> - -#include <boost/mpl/integral_c.hpp> -#include <boost/mpl/integral_c_tag.hpp> - -#include <type_traits> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace mpl { - //! @ingroup group-ext-mpl - //! Adapter for IntegralConstants from the Boost.MPL. - //! - //! Provided models - //! --------------- - //! 1. `Constant` and `IntegralConstant`\n - //! A Boost.MPL IntegralConstant is a model of the `IntegralConstant` - //! and `Constant` concepts just like `hana::integral_constant`s are. - //! As a consequence, they are also implicitly a model of the concepts - //! provided for all models of `Constant`. - //! @include example/ext/boost/mpl/integral_c/integral_constant.cpp - template <typename T, T v> - struct integral_c { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace mpl { - template <typename T> - struct integral_c_tag { using value_type = T; }; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename T::tag, - ::boost::mpl::integral_c_tag - >::value - >> { - using type = ext::boost::mpl::integral_c_tag< - typename hana::tag_of<typename T::value_type>::type - >; - }; - - ////////////////////////////////////////////////////////////////////////// - // IntegralConstant/Constant - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct IntegralConstant<ext::boost::mpl::integral_c_tag<T>> { - static constexpr bool value = true; - }; - - template <typename T, typename C> - struct to_impl<ext::boost::mpl::integral_c_tag<T>, C, - when<hana::IntegralConstant<C>::value> - > : embedding<is_embedded<typename C::value_type, T>::value> { - template <typename N> - static constexpr auto apply(N const&) { - return ::boost::mpl::integral_c<T, N::value>{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/mpl/list.hpp b/contrib/restricted/boost/boost/hana/ext/boost/mpl/list.hpp deleted file mode 100644 index 677b9a85bf..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/mpl/list.hpp +++ /dev/null @@ -1,186 +0,0 @@ -/*! -@file -Adapts `boost::mpl::list` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_MPL_LIST_HPP -#define BOOST_HANA_EXT_BOOST_MPL_LIST_HPP - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/ext/boost/mpl/integral_c.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/type.hpp> -#include <boost/hana/unpack.hpp> - -#include <boost/mpl/at.hpp> -#include <boost/mpl/empty.hpp> -#include <boost/mpl/equal.hpp> -#include <boost/mpl/list.hpp> -#include <boost/mpl/sequence_tag.hpp> -#include <boost/mpl/size.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace mpl { - //! @ingroup group-ext-mpl - //! Adapter for Boost.MPL lists. - //! - //! - //! Modeled concepts - //! ---------------- - //! It is possible for MPL lists to model a couple of concepts. - //! However, because they are only able to hold types, they lack - //! the generality required to model concepts like `Functor`, - //! `Sequence` and other related concepts. - //! - //! 1. `Comparable`\n - //! Two MPL lists are equal if and only if they contain the same - //! number of types, and if all those types are equal. - //! @include example/ext/boost/mpl/list/comparable.cpp - //! - //! 2. `Foldable`\n - //! Folding a MPL list is equivalent to folding it as a `Sequence`. - //! @include example/ext/boost/mpl/list/foldable.cpp - //! - //! 3. `Iterable`\n - //! Iterating over a MPL list is just iterating over each of the - //! types it contains, as if it were a `Sequence`. - //! @include example/ext/boost/mpl/list/iterable.cpp - //! - //! 4. `Searchable`\n - //! A MPL list can be searched as if it were a tuple containing - //! `hana::type`s. - //! @include example/ext/boost/mpl/list/searchable.cpp - //! - //! - //! Conversion from any `Foldable` - //! ------------------------------ - //! A MPL list can be created from any `Foldable`. More precisely, - //! for a `Foldable` `xs` whose linearization is `[x1, ..., xn]`, - //! @code - //! to<ext::boost::mpl::list_tag>(xs) == mpl::list<t1, ..., tn>{} - //! @endcode - //! where `tk` is the type of `xk`, or the type contained in `xk` if - //! `xk` is a `hana::type`. - //! @warning - //! The limitations on the size of `mpl::list`s are inherited by - //! this conversion utility, and hence trying to convert a `Foldable` - //! containing more than [BOOST_MPL_LIMIT_LIST_SIZE][1] elements is - //! an error. - //! @include example/ext/boost/mpl/list/conversion.cpp - //! - //! [1]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/limit-list-size.html - template <typename ...T> - struct list { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace mpl { - using list_tag = ::boost::mpl::sequence_tag< ::boost::mpl::list<>>::type; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename ::boost::mpl::sequence_tag<T>::type, - ::boost::mpl::sequence_tag< ::boost::mpl::list<>>::type - >::value - >> { - using type = ext::boost::mpl::list_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::boost::mpl::list_tag, ext::boost::mpl::list_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const&, Ys const&) { - return typename ::boost::mpl::equal<Xs, Ys>::type{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<ext::boost::mpl::list_tag> { - template <typename Xs> - static constexpr auto apply(Xs const&) { - return hana::size_c< ::boost::mpl::size<Xs>::type::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<ext::boost::mpl::list_tag> { - template <typename Ts, typename N> - static constexpr auto apply(Ts const&, N const&) { - constexpr std::size_t n = N::value; - using T = typename ::boost::mpl::at_c<Ts, n>::type; - return hana::type_c<T>; - } - }; - - template <> - struct drop_front_impl<ext::boost::mpl::list_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs const&, std::index_sequence<i...>) { - return boost::mpl::list< - typename boost::mpl::at_c<Xs, n + i>::type... - >{}; - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs const& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(xs, - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::boost::mpl::list_tag> { - template <typename Xs> - static constexpr auto apply(Xs const&) - { return typename ::boost::mpl::empty<Xs>::type{}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Conversion from a Foldable - ////////////////////////////////////////////////////////////////////////// - template <typename F> - struct to_impl<ext::boost::mpl::list_tag, F, when<hana::Foldable<F>::value>> { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - auto list_type = hana::unpack(static_cast<Xs&&>(xs), - hana::template_<::boost::mpl::list>); - return typename decltype(list_type)::type{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_MPL_LIST_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/mpl/vector.hpp b/contrib/restricted/boost/boost/hana/ext/boost/mpl/vector.hpp deleted file mode 100644 index 29e9972b5d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/mpl/vector.hpp +++ /dev/null @@ -1,185 +0,0 @@ -/*! -@file -Adapts `boost::mpl::vector` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP -#define BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/ext/boost/mpl/integral_c.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/type.hpp> -#include <boost/hana/unpack.hpp> - -#include <boost/mpl/at.hpp> -#include <boost/mpl/empty.hpp> -#include <boost/mpl/equal.hpp> -#include <boost/mpl/sequence_tag.hpp> -#include <boost/mpl/size.hpp> -#include <boost/mpl/vector.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { namespace mpl { - //! @ingroup group-ext-mpl - //! Adapter for Boost.MPL vectors. - //! - //! - //! Modeled concepts - //! ---------------- - //! It is possible for MPL vectors to model a couple of concepts. - //! However, because they are only able to hold types, they lack - //! the generality required to model concepts like `Functor`, - //! `Sequence` and other related concepts. - //! - //! 1. `Comparable`\n - //! Two MPL vectors are equal if and only if they contain the same - //! number of types, and if all those types are equal. - //! @include example/ext/boost/mpl/vector/comparable.cpp - //! - //! 2. `Foldable`\n - //! Folding a MPL vector is equivalent to folding it as a `Sequence`. - //! @include example/ext/boost/mpl/vector/foldable.cpp - //! - //! 3. `Iterable`\n - //! Iterating over a MPL vector is just iterating over each of the - //! types it contains, as if it were a `Sequence`. - //! @include example/ext/boost/mpl/vector/iterable.cpp - //! - //! 4. `Searchable`\n - //! A MPL vector can be searched as if it were a tuple containing - //! `hana::type`s. - //! @include example/ext/boost/mpl/vector/searchable.cpp - //! - //! - //! Conversion from any `Foldable` - //! ------------------------------ - //! A MPL vector can be created from any `Foldable`. More precisely, - //! for a `Foldable` `xs` whose linearization is `[x1, ..., xn]`, - //! @code - //! to<ext::boost::mpl::vector_tag>(xs) == mpl::vector<t1, ..., tn> - //! @endcode - //! where `tk` is the type of `xk`, or the type contained in `xk` if - //! `xk` is a `hana::type`. - //! @warning - //! The limitations on the size of `mpl::vector`s are inherited by - //! this conversion utility, and hence trying to convert a `Foldable` - //! containing more than [BOOST_MPL_LIMIT_VECTOR_SIZE][1] elements - //! is an error. - //! @include example/ext/boost/mpl/vector/conversion.cpp - //! - //! [1]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/limit-vector-size.html - template <typename ...T> - struct vector { }; -}} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { namespace mpl { - using vector_tag = ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type; - }}} - - template <typename T> - struct tag_of<T, when< - std::is_same< - typename ::boost::mpl::sequence_tag<T>::type, - ::boost::mpl::sequence_tag< ::boost::mpl::vector<>>::type - >::value - >> { - using type = ext::boost::mpl::vector_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::boost::mpl::vector_tag, ext::boost::mpl::vector_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const&, Ys const&) { - return typename ::boost::mpl::equal<Xs, Ys>::type{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<ext::boost::mpl::vector_tag> { - template <typename Xs> - static constexpr auto apply(Xs const&) { - return hana::size_c< ::boost::mpl::size<Xs>::type::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<ext::boost::mpl::vector_tag> { - template <typename Ts, typename N> - static constexpr auto apply(Ts const&, N const&) { - constexpr std::size_t n = N::value; - using T = typename ::boost::mpl::at_c<Ts, n>::type; - return hana::type_c<T>; - } - }; - - template <> - struct drop_front_impl<ext::boost::mpl::vector_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs const&, std::index_sequence<i...>) { - return boost::mpl::vector< - typename boost::mpl::at_c<Xs, n + i>::type... - >{}; - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs const& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(xs, - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::boost::mpl::vector_tag> { - template <typename xs> - static constexpr auto apply(xs) - { return typename ::boost::mpl::empty<xs>::type{}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Conversion from a Foldable - ////////////////////////////////////////////////////////////////////////// - template <typename F> - struct to_impl<ext::boost::mpl::vector_tag, F, when<hana::Foldable<F>::value>> { - template <typename Xs> - static constexpr auto apply(Xs const& xs) { - auto vector_type = hana::unpack(xs, hana::template_<boost::mpl::vector>); - return typename decltype(vector_type)::type{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_MPL_VECTOR_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/boost/tuple.hpp b/contrib/restricted/boost/boost/hana/ext/boost/tuple.hpp deleted file mode 100644 index 581c973bda..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/boost/tuple.hpp +++ /dev/null @@ -1,138 +0,0 @@ -/*! -@file -Adapts `boost::tuple` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_BOOST_TUPLE_HPP -#define BOOST_HANA_EXT_BOOST_TUPLE_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <boost/tuple/tuple.hpp> - -#include <cstddef> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace boost { - //! @ingroup group-ext-boost - //! Adapter for `boost::tuple`s. - //! - //! - //! Modeled concepts - //! ---------------- - //! A `boost::tuple` is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of Hana's tuple. - //! - //! @include example/ext/boost/tuple.cpp - template <typename ...T> - struct tuple { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace boost { struct tuple_tag; }} - - template <typename ...Xs> - struct tag_of<boost::tuple<Xs...>> { - using type = ext::boost::tuple_tag; - }; - - template <typename H, typename T> - struct tag_of<boost::tuples::cons<H, T>> { - using type = ext::boost::tuple_tag; - }; - - template <> - struct tag_of<boost::tuples::null_type> { - using type = ext::boost::tuple_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<ext::boost::tuple_tag> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - return static_cast<Xs&&>(xs).template get<n>(); - } - }; - - template <> - struct drop_front_impl<ext::boost::tuple_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<ext::boost::tuple_tag>( - hana::at_c<n + i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::boost::tuple_tag> { - static constexpr auto apply(boost::tuples::null_type const&) - { return hana::true_c; } - - template <typename H, typename T> - static constexpr auto apply(boost::tuples::cons<H, T> const&) - { return hana::false_c; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<ext::boost::tuple_tag> { - template <typename Xs> - static constexpr auto apply(Xs const&) { - return hana::size_c<boost::tuples::length<Xs>::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct Sequence<ext::boost::tuple_tag> { - static constexpr bool value = true; - }; - - template <> - struct make_impl<ext::boost::tuple_tag> { - template <typename ...Xs> - static constexpr auto apply(Xs&& ...xs) { - return boost::tuples::tuple< - typename detail::decay<Xs>::type... - >{static_cast<Xs&&>(xs)...}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_BOOST_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std.hpp b/contrib/restricted/boost/boost/hana/ext/std.hpp deleted file mode 100644 index 988ce93241..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std.hpp +++ /dev/null @@ -1,25 +0,0 @@ -/*! -@file -Includes all the adaptors for the standard library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_HPP -#define BOOST_HANA_EXT_STD_HPP - -//! @ingroup group-ext -//! @defgroup group-ext-std Standard library adapters -//! Adapters for components in the standard library. - -#include <boost/hana/ext/std/array.hpp> -#include <boost/hana/ext/std/integer_sequence.hpp> -#include <boost/hana/ext/std/integral_constant.hpp> -#include <boost/hana/ext/std/pair.hpp> -#include <boost/hana/ext/std/ratio.hpp> -#include <boost/hana/ext/std/tuple.hpp> -#include <boost/hana/ext/std/vector.hpp> - -#endif // !BOOST_HANA_EXT_STD_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/array.hpp b/contrib/restricted/boost/boost/hana/ext/std/array.hpp deleted file mode 100644 index 59bc49cf8d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/array.hpp +++ /dev/null @@ -1,171 +0,0 @@ -/*! -@file -Adapts `std::array` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_ARRAY_HPP -#define BOOST_HANA_EXT_STD_ARRAY_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <array> -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adaptation of `std::array` for Hana. - //! - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! `std::array`s are compared as per `std::equal`, except that two arrays - //! with different sizes compare unequal instead of triggering an error - //! and the result of the comparison is `constexpr` if both arrays are - //! `constexpr`. - //! @include example/ext/std/array/comparable.cpp - //! - //! 2. `Orderable`\n - //! `std::array`s are ordered with the usual lexicographical ordering, - //! except that two arrays with different size can be ordered instead - //! of triggering an error and the result of the comparison is `constexpr` - //! if both arrays are `constexpr`. - //! @include example/ext/std/array/orderable.cpp - //! - //! 3. `Foldable`\n - //! Folding an array from the left is equivalent to calling - //! `std::accumulate` on it, except it can be `constexpr`. - //! @include example/ext/std/array/foldable.cpp - //! - //! 4. `Iterable`\n - //! Iterating over a `std::array` is equivalent to iterating over it with - //! a normal `for` loop. - //! @include example/ext/std/array/iterable.cpp - template <typename T, std::size_t N> - struct array { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct array_tag; }} - - template <typename T, std::size_t N> - struct tag_of<std::array<T, N>> { - using type = ext::std::array_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<ext::std::array_tag> { - template <typename Xs> - static constexpr auto apply(Xs const&) { - return hana::size_c<std::tuple_size<Xs>::type::value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<ext::std::array_tag> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - return std::get<n>(static_cast<Xs&&>(xs)); - } - }; - - template <> - struct drop_front_impl<ext::std::array_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - using T = typename std::remove_reference<Xs>::type::value_type; - return std::array<T, sizeof...(i)>{{static_cast<Xs&&>(xs)[n + i]...}}; - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = std::tuple_size< - typename std::remove_cv< - typename std::remove_reference<Xs>::type - >::type - >::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::std::array_tag> { - template <typename T, std::size_t N> - static constexpr auto apply(std::array<T, N> const&) { - return hana::bool_c<N == 0>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::std::array_tag, ext::std::array_tag> { - template <typename T, std::size_t n, typename U> - static constexpr bool apply(std::array<T, n> const& xs, std::array<U, n> const& ys) - { return detail::equal(&xs[0], &xs[0] + n, &ys[0], &ys[0] + n); } - - template <typename T, typename U> - static constexpr auto apply(std::array<T, 0> const&, std::array<U, 0> const&) - { return hana::true_c; } - - template <typename T, std::size_t n, typename U, std::size_t m> - static constexpr auto apply(std::array<T, n> const&, std::array<U, m> const&) - { return hana::false_c; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Orderable - ////////////////////////////////////////////////////////////////////////// - template <> - struct less_impl<ext::std::array_tag, ext::std::array_tag> { - template <typename T, std::size_t n, typename U, std::size_t m> - static constexpr auto apply(std::array<T, n> const& xs, std::array<U, m> const& ys) { - // This logic is more complex than it needs to be because we can't - // use `.begin()` and `.end()`, which are not constexpr in C++14, - // and because `&arr[0]` is UB when the array is empty. - if (xs.empty()) { - return !ys.empty(); - } else { - if (ys.empty()) { - return false; - } else { - return detail::lexicographical_compare(&xs[0], &xs[0] + n, - &ys[0], &ys[0] + m); - } - } - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_ARRAY_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/integer_sequence.hpp b/contrib/restricted/boost/boost/hana/ext/std/integer_sequence.hpp deleted file mode 100644 index 83536a3102..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/integer_sequence.hpp +++ /dev/null @@ -1,140 +0,0 @@ -/*! -@file -Adapts `std::integer_sequence` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP -#define BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/ext/std/integral_constant.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/unpack.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adaptation of `std::integer_sequence` for Hana. - //! - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two `std::integer_sequence`s are equal if and only if they have the - //! same number of elements, and if corresponding elements compare equal. - //! The types of the elements held in both `integer_sequence`s may be - //! different, as long as they can be compared. - //! @include example/ext/std/integer_sequence/comparable.cpp - //! - //! 2. `Foldable`\n - //! Folding an `integer_sequence` is equivalent to folding a sequence of - //! `std::integral_constant`s with the corresponding types. - //! @include example/ext/std/integer_sequence/foldable.cpp - //! - //! 3. `Iterable`\n - //! Iterating over an `integer_sequence` is equivalent to iterating over - //! a sequence of the corresponding `std::integral_constant`s. - //! @include example/ext/std/integer_sequence/iterable.cpp - //! - //! 4. `Searchable`\n - //! Searching through an `integer_sequence` is equivalent to searching - //! through the corresponding sequence of `std::integral_constant`s. - //! @include example/ext/std/integer_sequence/searchable.cpp - template <typename T, T ...v> - struct integer_sequence { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct integer_sequence_tag; }} - - template <typename T, T ...v> - struct tag_of<std::integer_sequence<T, v...>> { - using type = ext::std::integer_sequence_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::std::integer_sequence_tag, ext::std::integer_sequence_tag> { - template <typename X, X ...xs, typename Y, Y ...ys> - static constexpr hana::bool_<detail::fast_and<(xs == ys)...>::value> - apply(std::integer_sequence<X, xs...> const&, std::integer_sequence<Y, ys...> const&) - { return {}; } - - template <typename Xs, typename Ys> - static constexpr hana::false_ apply(Xs const&, Ys const&, ...) - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<ext::std::integer_sequence_tag> { - template <typename T, T ...v, typename F> - static constexpr decltype(auto) - apply(std::integer_sequence<T, v...> const&, F&& f) { - return static_cast<F&&>(f)(std::integral_constant<T, v>{}...); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<ext::std::integer_sequence_tag> { - template <typename T, T ...v, typename N> - static constexpr auto apply(std::integer_sequence<T, v...> const&, N const&) { - constexpr std::size_t n = N::value; - constexpr T values_[] = {v...}; - return std::integral_constant<T, values_[n]>{}; - } - }; - - template <> - struct drop_front_impl<ext::std::integer_sequence_tag> { - template <std::size_t n, typename T, T ...t, std::size_t ...i> - static constexpr auto drop_front_helper(std::integer_sequence<T, t...>, - std::index_sequence<i...>) - { - constexpr T ts[sizeof...(t)+1] = {t...}; // avoid 0-sized array - return std::integer_sequence<T, ts[n + i]...>{}; - } - - template <typename T, T ...t, typename N> - static constexpr auto apply(std::integer_sequence<T, t...> ts, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = sizeof...(t); - return drop_front_helper<n>(ts, - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::std::integer_sequence_tag> { - template <typename T, T ...xs> - static constexpr auto apply(std::integer_sequence<T, xs...> const&) - { return hana::bool_c<sizeof...(xs) == 0>; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_INTEGER_SEQUENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/integral_constant.hpp b/contrib/restricted/boost/boost/hana/ext/std/integral_constant.hpp deleted file mode 100644 index f949a66481..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/integral_constant.hpp +++ /dev/null @@ -1,96 +0,0 @@ -/*! -@file -Adapts `std::integral_constant` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/integral_constant.hpp> - -#include <type_traits> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adapter for `std::integral_constant`s. - //! - //! Provided models - //! --------------- - //! 1. `Constant` and `IntegralConstant`\n - //! A `std::integral_constant` is a model of the `IntegralConstant` and - //! `Constant` concepts, just like `hana::integral_constant`s are. As a - //! consequence, they are also implicitly a model of the concepts provided - //! for all models of `Constant`. - //! @include example/ext/std/integral_constant.cpp - template <typename T, T v> - struct integral_constant { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { - template <typename T> - struct integral_constant_tag { using value_type = T; }; - }} - - namespace detail { - template <typename T, T v> - constexpr bool - is_std_integral_constant(std::integral_constant<T, v>*) - { return true; } - - constexpr bool is_std_integral_constant(...) - { return false; } - - - template <typename T, T v> - constexpr bool - is_hana_integral_constant(hana::integral_constant<T, v>*) - { return true; } - - constexpr bool is_hana_integral_constant(...) - { return false; } - } - - template <typename T> - struct tag_of<T, when< - detail::is_std_integral_constant((T*)0) && - !detail::is_hana_integral_constant((T*)0) - >> { - using type = ext::std::integral_constant_tag< - typename hana::tag_of<typename T::value_type>::type - >; - }; - - ////////////////////////////////////////////////////////////////////////// - // Constant/IntegralConstant - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct IntegralConstant<ext::std::integral_constant_tag<T>> { - static constexpr bool value = true; - }; - - template <typename T, typename C> - struct to_impl<ext::std::integral_constant_tag<T>, C, when< - hana::IntegralConstant<C>::value - >> : embedding<is_embedded<typename C::value_type, T>::value> { - template <typename N> - static constexpr auto apply(N const&) { - return std::integral_constant<T, N::value>{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/pair.hpp b/contrib/restricted/boost/boost/hana/ext/std/pair.hpp deleted file mode 100644 index a2f429a642..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/pair.hpp +++ /dev/null @@ -1,91 +0,0 @@ -/*! -@file -Adapts `std::pair` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_PAIR_HPP -#define BOOST_HANA_EXT_STD_PAIR_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/first.hpp> -#include <boost/hana/fwd/second.hpp> - -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adaptation of `std::pair` for Hana. - //! - //! - //! Modeled concepts - //! ---------------- - //! A `std::pair` models exactly the same concepts as a `hana::pair`. - //! Please refer to the documentation of `hana::pair` for details. - //! - //! @include example/ext/std/pair.cpp - template <typename First, typename Second> - struct pair { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct pair_tag; }} - - template <typename First, typename Second> - struct tag_of<std::pair<First, Second>> { - using type = ext::std::pair_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Product - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<ext::std::pair_tag> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return std::make_pair(static_cast<X&&>(x), - static_cast<Y&&>(y)); - } - }; - - template <> - struct first_impl<ext::std::pair_tag> { - template <typename T, typename U> - static constexpr T const& apply(std::pair<T, U> const& p) - { return p.first; } - - template <typename T, typename U> - static constexpr T& apply(std::pair<T, U>& p) - { return p.first; } - - template <typename T, typename U> - static constexpr T&& apply(std::pair<T, U>&& p) - { return static_cast<T&&>(p.first); } - }; - - template <> - struct second_impl<ext::std::pair_tag> { - template <typename T, typename U> - static constexpr U const& apply(std::pair<T, U> const& p) - { return p.second; } - - template <typename T, typename U> - static constexpr U& apply(std::pair<T, U>& p) - { return p.second; } - - template <typename T, typename U> - static constexpr U&& apply(std::pair<T, U>&& p) - { return static_cast<U&&>(p.second); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_PAIR_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/ratio.hpp b/contrib/restricted/boost/boost/hana/ext/std/ratio.hpp deleted file mode 100644 index bf25632f7d..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/ratio.hpp +++ /dev/null @@ -1,164 +0,0 @@ -/*! -@file -Adapts `std::ratio` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_RATIO_HPP -#define BOOST_HANA_EXT_STD_RATIO_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/div.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/fwd/minus.hpp> -#include <boost/hana/fwd/mod.hpp> -#include <boost/hana/fwd/mult.hpp> -#include <boost/hana/fwd/one.hpp> -#include <boost/hana/fwd/plus.hpp> -#include <boost/hana/fwd/zero.hpp> - -#include <cstdint> -#include <ratio> -#include <type_traits> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adaptation of `std::ratio` for Hana. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! `std::ratio`s are compared for equality using `std::ratio_equal`. - //! @include example/ext/std/ratio/comparable.cpp - //! - //! 2. `Orderable`\n - //! `std::ratio`s are ordered using `std::ratio_less`. - //! @include example/ext/std/ratio/orderable.cpp - //! - //! 3. `Monoid`, `Group`, `Ring`, and `EuclideanRing`\n - //! `std::ratio`s are added, subtracted, multiplied and divided using - //! `std::ratio_add`, `std::ratio_subtract`, `std::ratio_multiply` and - //! `std::ratio_divide`, respectively. Furthermore, the neutral element - //! for the additive operation is `std::ratio<0, 1>{}`, and the neutral - //! element for the multiplicative operation is `std::ratio<1, 1>{}`. - //! @include example/ext/std/ratio/arithmetic.cpp - template <std::intmax_t Num, std::intmax_t Denom> - class ratio { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct ratio_tag; }} - - template <std::intmax_t num, std::intmax_t den> - struct tag_of<std::ratio<num, den>> { - using type = ext::std::ratio_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Conversion from IntegralConstants - ////////////////////////////////////////////////////////////////////////// - template <typename C> - struct to_impl<ext::std::ratio_tag, C, when< - hana::IntegralConstant<C>::value - >> { - template <typename N> - static constexpr auto apply(N const&) { - return std::ratio<N::value>{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr auto apply(R1 const&, R2 const&) - { return hana::bool_c<std::ratio_equal<R1, R2>::value>; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Orderable - ////////////////////////////////////////////////////////////////////////// - template <> - struct less_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr auto apply(R1 const&, R2 const&) - { return hana::bool_c<std::ratio_less<R1, R2>::value>; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Monoid - ////////////////////////////////////////////////////////////////////////// - template <> - struct plus_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr std::ratio_add<R1, R2> apply(R1 const&, R2 const&) - { return {}; } - }; - - template <> - struct zero_impl<ext::std::ratio_tag> { - static constexpr std::ratio<0> apply() - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Group - ////////////////////////////////////////////////////////////////////////// - template <> - struct minus_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr std::ratio_subtract<R1, R2> apply(R1 const&, R2 const&) - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Ring - ////////////////////////////////////////////////////////////////////////// - template <> - struct mult_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr std::ratio_multiply<R1, R2> apply(R1 const&, R2 const&) - { return {}; } - }; - - template <> - struct one_impl<ext::std::ratio_tag> { - static constexpr std::ratio<1> apply() - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // EuclideanRing - ////////////////////////////////////////////////////////////////////////// - template <> - struct div_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr std::ratio_divide<R1, R2> apply(R1 const&, R2 const&) - { return {}; } - }; - - template <> - struct mod_impl<ext::std::ratio_tag, ext::std::ratio_tag> { - template <typename R1, typename R2> - static constexpr std::ratio<0> apply(R1 const&, R2 const&) - { return {}; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_RATIO_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/tuple.hpp b/contrib/restricted/boost/boost/hana/ext/std/tuple.hpp deleted file mode 100644 index 53f8909325..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/tuple.hpp +++ /dev/null @@ -1,184 +0,0 @@ -/*! -@file -Adapts `std::tuple` for use with Hana. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_TUPLE_HPP -#define BOOST_HANA_EXT_STD_TUPLE_HPP - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/empty.hpp> -#include <boost/hana/fwd/flatten.hpp> -#include <boost/hana/fwd/front.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/lift.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <cstddef> -#include <tuple> -#include <type_traits> -#include <utility> - - -#ifdef BOOST_HANA_DOXYGEN_INVOKED -namespace std { - //! @ingroup group-ext-std - //! Adapter for `std::tuple`s. - //! - //! - //! Modeled concepts - //! ---------------- - //! A `std::tuple` is a model of the `Sequence` concept, and all the - //! concepts it refines. That makes it essentially the same as a Hana - //! tuple, although the complexity of some operations might differ from - //! that of Hana's tuple. - //! - //! @include example/ext/std/tuple.cpp - template <typename ...T> - struct tuple { }; -} -#endif - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct tuple_tag; }} - - template <typename ...Xs> - struct tag_of<std::tuple<Xs...>> { - using type = ext::std::tuple_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // make - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<ext::std::tuple_tag> { - template <typename ...Xs> - static constexpr decltype(auto) apply(Xs&& ...xs) { - return std::make_tuple(static_cast<Xs&&>(xs)...); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Applicative - ////////////////////////////////////////////////////////////////////////// - template <> - struct lift_impl<ext::std::tuple_tag> { - template <typename X> - static constexpr auto apply(X&& x) { - return std::tuple<typename detail::decay<X>::type>{ - static_cast<X&&>(x)}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Monad - ////////////////////////////////////////////////////////////////////////// - template <> - struct flatten_impl<ext::std::tuple_tag> { - template <typename Xs, std::size_t ...i> - static constexpr decltype(auto) - flatten_helper(Xs&& xs, std::index_sequence<i...>) { -#if defined(BOOST_HANA_CONFIG_LIBCPP_HAS_BUG_22806) - return std::tuple_cat(std::get<i>(xs)...); -#else - return std::tuple_cat(std::get<i>(static_cast<Xs&&>(xs))...); -#endif - } - - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - using Raw = typename std::remove_reference<Xs>::type; - constexpr std::size_t Length = std::tuple_size<Raw>::value; - return flatten_helper(static_cast<Xs&&>(xs), - std::make_index_sequence<Length>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // MonadPlus - ////////////////////////////////////////////////////////////////////////// - template <> - struct empty_impl<ext::std::tuple_tag> { - static constexpr auto apply() - { return std::tuple<>{}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct front_impl<ext::std::tuple_tag> { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - return std::get<0>(static_cast<Xs&&>(xs)); - } - }; - - template <> - struct drop_front_impl<ext::std::tuple_tag> { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) { - return std::make_tuple( - hana::at_c<n + i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - using Raw = typename std::remove_reference<Xs>::type; - constexpr std::size_t n = N::value; - constexpr auto len = std::tuple_size<Raw>::value; - return drop_front_helper<n>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? len - n : 0)>{}); - } - }; - - template <> - struct is_empty_impl<ext::std::tuple_tag> { - template <typename ...Xs> - static constexpr auto apply(std::tuple<Xs...> const&) - { return hana::bool_c<sizeof...(Xs) == 0>; } - }; - - template <> - struct at_impl<ext::std::tuple_tag> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t index = N::value; - return std::get<index>(static_cast<Xs&&>(xs)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct length_impl<ext::std::tuple_tag> { - template <typename ...Xs> - static constexpr auto apply(std::tuple<Xs...> const&) { - return hana::size_c<sizeof...(Xs)>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct Sequence<ext::std::tuple_tag> { - static constexpr bool value = true; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/ext/std/vector.hpp b/contrib/restricted/boost/boost/hana/ext/std/vector.hpp deleted file mode 100644 index d286d8f9a8..0000000000 --- a/contrib/restricted/boost/boost/hana/ext/std/vector.hpp +++ /dev/null @@ -1,110 +0,0 @@ -/*! -@file -Adapts `std::vector` for use with Hana. - -@copyright Louis Dionne 2013-2017 -@copyright Gonzalo Brito Gadeschi 2015 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXT_STD_VECTOR_HPP -#define BOOST_HANA_EXT_STD_VECTOR_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/less.hpp> - -#include <algorithm> -#include <iterator> -#include <memory> -#include <type_traits> -#include <utility> -#include <vector> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace ext { namespace std { struct vector_tag; }} - - template <typename T, typename Allocator> - struct tag_of<std::vector<T, Allocator>> { - using type = ext::std::vector_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<ext::std::vector_tag, ext::std::vector_tag> { - template <typename T1, typename A1, typename T2, typename A2> - static bool apply(std::vector<T1, A1> const& v1, - std::vector<T2, A2> const& v2) - { - return std::equal(begin(v1), end(v1), - begin(v2), end(v2), - hana::equal); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Orderable - ////////////////////////////////////////////////////////////////////////// - template <> - struct less_impl<ext::std::vector_tag, ext::std::vector_tag> { - template <typename T1, typename A1, typename T2, typename A2> - static bool apply(std::vector<T1, A1> const& v1, - std::vector<T2, A2> const& v2) - { - return std::lexicographical_compare(begin(v1), end(v1), - begin(v2), end(v2), - hana::less); - } - }; - -#if 0 - ////////////////////////////////////////////////////////////////////////// - // Functor - ////////////////////////////////////////////////////////////////////////// - template <> - struct transform_impl<ext::std::vector_tag> { - template <typename V, typename F> - static auto apply(V&& v, F&& f) { - using U = std::remove_cv_t<std::remove_reference_t< - decltype(f(*v.begin())) - >>; - using Alloc = typename std::remove_reference_t<V>::allocator_type; - using NewAlloc = typename std::allocator_traits<Alloc>:: - template rebind_alloc<U>; - std::vector<U, NewAlloc> result; result.reserve(v.size()); - - std::transform(begin(v), end(v), - std::back_inserter(result), std::forward<F>(f)); - return result; - } - - template <typename T, typename Alloc, typename F> - static auto apply(std::vector<T, Alloc>&& v, F&& f) - -> std::enable_if_t< - std::is_same< - T, - std::remove_cv_t<std::remove_reference_t< - decltype(f(*v.begin())) - >> - >{} - , std::vector<T, Alloc> - > - { - // If we receive a rvalue and the function returns elements of - // the same type, we modify the vector in-place instead of - // returning a new one. - std::transform(std::make_move_iterator(begin(v)), - std::make_move_iterator(end(v)), - begin(v), std::forward<F>(f)); - return std::move(v); - } - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXT_STD_VECTOR_HPP diff --git a/contrib/restricted/boost/boost/hana/extend.hpp b/contrib/restricted/boost/boost/hana/extend.hpp deleted file mode 100644 index 466e74e777..0000000000 --- a/contrib/restricted/boost/boost/hana/extend.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Defines `boost::hana::extend`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXTEND_HPP -#define BOOST_HANA_EXTEND_HPP - -#include <boost/hana/fwd/extend.hpp> - -#include <boost/hana/concept/comonad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/duplicate.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename W_, typename F> - constexpr decltype(auto) extend_t::operator()(W_&& w, F&& f) const { - using W = typename hana::tag_of<W_>::type; - using Extend = BOOST_HANA_DISPATCH_IF(extend_impl<W>, - hana::Comonad<W>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Comonad<W>::value, - "hana::extend(w, f) requires 'w' to be a Comonad"); - #endif - - return Extend::apply(static_cast<W_&&>(w), static_cast<F&&>(f)); - } - //! @endcond - - template <typename W, bool condition> - struct extend_impl<W, when<condition>> : default_ { - template <typename X, typename F> - static constexpr decltype(auto) apply(X&& x, F&& f) { - return hana::transform(hana::duplicate(static_cast<X&&>(x)), - static_cast<F&&>(f)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXTEND_HPP diff --git a/contrib/restricted/boost/boost/hana/extract.hpp b/contrib/restricted/boost/boost/hana/extract.hpp deleted file mode 100644 index a9cd58624c..0000000000 --- a/contrib/restricted/boost/boost/hana/extract.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Defines `boost::hana::extract`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_EXTRACT_HPP -#define BOOST_HANA_EXTRACT_HPP - -#include <boost/hana/fwd/extract.hpp> - -#include <boost/hana/concept/comonad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename W_> - constexpr decltype(auto) extract_t::operator()(W_&& w) const { - using W = typename hana::tag_of<W_>::type; - using Extract = BOOST_HANA_DISPATCH_IF(extract_impl<W>, - hana::Comonad<W>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Comonad<W>::value, - "hana::extract(w) requires 'w' to be a Comonad"); - #endif - - return Extract::apply(static_cast<W_&&>(w)); - } - //! @endcond - - template <typename W, bool condition> - struct extract_impl<W, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...args) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_EXTRACT_HPP diff --git a/contrib/restricted/boost/boost/hana/fill.hpp b/contrib/restricted/boost/boost/hana/fill.hpp deleted file mode 100644 index de82ac9b8e..0000000000 --- a/contrib/restricted/boost/boost/hana/fill.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Defines `boost::hana::fill`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FILL_HPP -#define BOOST_HANA_FILL_HPP - -#include <boost/hana/fwd/fill.hpp> - -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/functional/always.hpp> -#include <boost/hana/transform.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Value> - constexpr auto fill_t::operator()(Xs&& xs, Value&& value) const { - using S = typename hana::tag_of<Xs>::type; - using Fill = BOOST_HANA_DISPATCH_IF(fill_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::fill(xs, value) requires 'xs' to be a Functor"); - #endif - - return Fill::apply(static_cast<Xs&&>(xs), - static_cast<Value&&>(value)); - } - //! @endcond - - template <typename Fun, bool condition> - struct fill_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename Value> - static constexpr auto apply(Xs&& xs, Value&& v) { - return hana::transform(static_cast<Xs&&>(xs), - hana::always(static_cast<Value&&>(v)) - ); - } - }; - - template <typename S> - struct fill_impl<S, when<Sequence<S>::value>> { - //! @cond - template <typename V> - struct filler { - V const& v; - template <typename ...Xs> - constexpr auto operator()(Xs const& ...xs) const { - return hana::make<S>(((void)xs, v)...); - } - }; - //! @endcond - - template <typename Xs, typename V> - static constexpr auto apply(Xs const& xs, V const& v) { - return hana::unpack(xs, filler<V>{v}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FILL_HPP diff --git a/contrib/restricted/boost/boost/hana/filter.hpp b/contrib/restricted/boost/boost/hana/filter.hpp deleted file mode 100644 index e8f7d51428..0000000000 --- a/contrib/restricted/boost/boost/hana/filter.hpp +++ /dev/null @@ -1,135 +0,0 @@ -/*! -@file -Defines `boost::hana::filter`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FILTER_HPP -#define BOOST_HANA_FILTER_HPP - -#include <boost/hana/fwd/filter.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/lift.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto filter_t::operator()(Xs&& xs, Pred&& pred) const { - using M = typename hana::tag_of<Xs>::type; - using Filter = BOOST_HANA_DISPATCH_IF(filter_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::filter(xs, pred) requires 'xs' to be a MonadPlus"); - #endif - - return Filter::apply(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - //! @endcond - - namespace detail { - template <typename Pred, typename M> - struct lift_or_empty { - template <typename X> - static constexpr auto helper(X&& x, hana::true_) - { return hana::lift<M>(static_cast<X&&>(x)); } - - template <typename X> - static constexpr auto helper(X&&, hana::false_) - { return hana::empty<M>(); } - - template <typename X> - constexpr auto operator()(X&& x) const { - constexpr bool cond = decltype(std::declval<Pred>()(x))::value; - return helper(static_cast<X&&>(x), hana::bool_c<cond>); - } - }; - } - - template <typename M, bool condition> - struct filter_impl<M, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr decltype(auto) apply(Xs&& xs, Pred const&) { - return hana::chain(static_cast<Xs&&>(xs), - detail::lift_or_empty<Pred, M>{} - ); - } - }; - - namespace detail { - template <bool ...b> - struct filter_indices { - static constexpr auto compute_indices() { - constexpr bool bs[] = {b..., false}; // avoid empty array - constexpr std::size_t N = detail::count(bs, bs + sizeof(bs), true); - detail::array<std::size_t, N> indices{}; - std::size_t* keep = &indices[0]; - for (std::size_t i = 0; i < sizeof...(b); ++i) - if (bs[i]) - *keep++ = i; - return indices; - } - - static constexpr auto cached_indices = compute_indices(); - }; - - template <typename Pred> - struct make_filter_indices { - Pred const& pred; - template <typename ...X> - auto operator()(X&& ...x) const -> filter_indices< - static_cast<bool>(detail::decay< - decltype(pred(static_cast<X&&>(x))) - >::type::value)... - > { return {}; } - }; - } - - template <typename S> - struct filter_impl<S, when<Sequence<S>::value>> { - template <typename Indices, typename Xs, std::size_t ...i> - static constexpr auto filter_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<S>( - hana::at_c<Indices::cached_indices[i]>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred const& pred) { - using Indices = decltype( - hana::unpack(static_cast<Xs&&>(xs), - detail::make_filter_indices<Pred>{pred}) - ); - - return filter_impl::filter_helper<Indices>( - static_cast<Xs&&>(xs), - std::make_index_sequence<Indices::cached_indices.size()>{} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FILTER_HPP diff --git a/contrib/restricted/boost/boost/hana/find.hpp b/contrib/restricted/boost/boost/hana/find.hpp deleted file mode 100644 index 4ebc48a2b5..0000000000 --- a/contrib/restricted/boost/boost/hana/find.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Defines `boost::hana::find`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FIND_HPP -#define BOOST_HANA_FIND_HPP - -#include <boost/hana/fwd/find.hpp> - -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/find_if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Key> - constexpr auto find_t::operator()(Xs&& xs, Key const& key) const { - using S = typename hana::tag_of<Xs>::type; - using Find = BOOST_HANA_DISPATCH_IF(find_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::find(xs, key) requires 'xs' to be Searchable"); - #endif - - return Find::apply(static_cast<Xs&&>(xs), key); - } - //! @endcond - - namespace detail { - template <typename T> - struct equal_to { - T const& t; - template <typename U> - constexpr auto operator()(U const& u) const { - return hana::equal(t, u); - } - }; - } - - template <typename S, bool condition> - struct find_impl<S, when<condition>> : default_ { - template <typename Xs, typename Key> - static constexpr auto apply(Xs&& xs, Key const& key) { - return hana::find_if(static_cast<Xs&&>(xs), - detail::equal_to<Key>{key}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FIND_HPP diff --git a/contrib/restricted/boost/boost/hana/find_if.hpp b/contrib/restricted/boost/boost/hana/find_if.hpp deleted file mode 100644 index de9c3d3eea..0000000000 --- a/contrib/restricted/boost/boost/hana/find_if.hpp +++ /dev/null @@ -1,129 +0,0 @@ -/*! -@file -Defines `boost::hana::find_if`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FIND_IF_HPP -#define BOOST_HANA_FIND_IF_HPP - -#include <boost/hana/fwd/find_if.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/index_if.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/transform.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto find_if_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using FindIf = BOOST_HANA_DISPATCH_IF(find_if_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::find_if(xs, pred) requires 'xs' to be a Searchable"); - #endif - - return FindIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct find_if_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - namespace detail { - template <typename Xs> - struct partial_at { - Xs const& xs; - - template <typename I> - constexpr decltype(auto) operator()(I i) const { - return hana::at(xs, i); - } - }; - } - - template <typename Tag> - struct find_if_impl<Tag, when<Iterable<Tag>::value>> { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - using Result = decltype(hana::index_if( - static_cast<Xs&&>(xs), static_cast<Pred&&>(pred))); - - return hana::transform(Result{}, - detail::partial_at<std::decay_t<Xs>>{static_cast<Xs&&>(xs)}); - } - }; - - template <typename T, std::size_t N> - struct find_if_impl<T[N]> { - template <typename Xs> - static constexpr auto find_if_helper(Xs&&, hana::false_) - { return hana::nothing; } - - template <typename Xs> - static constexpr auto find_if_helper(Xs&& xs, hana::true_) - { return hana::just(static_cast<Xs&&>(xs)[0]); } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return find_if_helper(static_cast<Xs&&>(xs), - hana::bool_c<decltype( - static_cast<Pred&&>(pred)(static_cast<Xs&&>(xs)[0]) - )::value> - ); - } - }; - - namespace struct_detail { - template <typename X> - struct get_member { - X x; - template <typename Member> - constexpr decltype(auto) operator()(Member&& member) && { - return hana::second(static_cast<Member&&>(member))( - static_cast<X&&>(x) - ); - } - }; - } - - template <typename S> - struct find_if_impl<S, when<hana::Struct<S>::value>> { - template <typename X, typename Pred> - static constexpr decltype(auto) apply(X&& x, Pred&& pred) { - return hana::transform( - hana::find_if(hana::accessors<S>(), - hana::compose(static_cast<Pred&&>(pred), hana::first) - ), - struct_detail::get_member<X>{static_cast<X&&>(x)} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FIND_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/first.hpp b/contrib/restricted/boost/boost/hana/first.hpp deleted file mode 100644 index f364b2242f..0000000000 --- a/contrib/restricted/boost/boost/hana/first.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Defines `boost::hana::first`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FIRST_HPP -#define BOOST_HANA_FIRST_HPP - -#include <boost/hana/fwd/first.hpp> - -#include <boost/hana/concept/product.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Pair> - constexpr decltype(auto) first_t::operator()(Pair&& pair) const { - using P = typename hana::tag_of<Pair>::type; - using First = BOOST_HANA_DISPATCH_IF(first_impl<P>, - hana::Product<P>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Product<P>::value, - "hana::first(pair) requires 'pair' to be a Product"); - #endif - - return First::apply(static_cast<Pair&&>(pair)); - } - //! @endcond - - template <typename P, bool condition> - struct first_impl<P, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FIRST_HPP diff --git a/contrib/restricted/boost/boost/hana/flatten.hpp b/contrib/restricted/boost/boost/hana/flatten.hpp deleted file mode 100644 index 6c5ccc99c3..0000000000 --- a/contrib/restricted/boost/boost/hana/flatten.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Defines `boost::hana::flatten`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FLATTEN_HPP -#define BOOST_HANA_FLATTEN_HPP - -#include <boost/hana/fwd/flatten.hpp> - -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/unpack_flatten.hpp> -#include <boost/hana/functional/id.hpp> -#include <boost/hana/fwd/chain.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto flatten_t::operator()(Xs&& xs) const { - using M = typename hana::tag_of<Xs>::type; - using Flatten = BOOST_HANA_DISPATCH_IF(flatten_impl<M>, - hana::Monad<M>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::flatten(xs) requires 'xs' to be a Monad"); -#endif - - return Flatten::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename M, bool condition> - struct flatten_impl<M, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return hana::chain(static_cast<Xs&&>(xs), hana::id); } - }; - - template <typename S> - struct flatten_impl<S, when<Sequence<S>::value>> { - template <typename Xs> - static constexpr auto apply(Xs&& xs) { - return detail::unpack_flatten(static_cast<Xs&&>(xs), hana::make<S>); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FLATTEN_HPP diff --git a/contrib/restricted/boost/boost/hana/fold.hpp b/contrib/restricted/boost/boost/hana/fold.hpp deleted file mode 100644 index a3665de22f..0000000000 --- a/contrib/restricted/boost/boost/hana/fold.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/*! -@file -Defines `boost::hana::fold`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FOLD_HPP -#define BOOST_HANA_FOLD_HPP - -#include <boost/hana/fwd/fold.hpp> - -#include <boost/hana/fold_left.hpp> - -#endif // !BOOST_HANA_FOLD_HPP diff --git a/contrib/restricted/boost/boost/hana/fold_left.hpp b/contrib/restricted/boost/boost/hana/fold_left.hpp deleted file mode 100644 index fc51b84d70..0000000000 --- a/contrib/restricted/boost/boost/hana/fold_left.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*! -@file -Defines `boost::hana::fold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FOLD_LEFT_HPP -#define BOOST_HANA_FOLD_LEFT_HPP - -#include <boost/hana/fwd/fold_left.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/variadic/foldl1.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename State, typename F> - constexpr decltype(auto) fold_left_t::operator()(Xs&& xs, State&& state, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using FoldLeft = BOOST_HANA_DISPATCH_IF(fold_left_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::fold_left(xs, state, f) requires 'xs' to be Foldable"); - #endif - - return FoldLeft::apply(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - - template <typename Xs, typename F> - constexpr decltype(auto) fold_left_t::operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using FoldLeft = BOOST_HANA_DISPATCH_IF(fold_left_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::fold_left(xs, f) requires 'xs' to be Foldable"); - #endif - - return FoldLeft::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - namespace detail { - template <typename F, typename State> - struct variadic_foldl1 { - F& f; - State& state; - template <typename ...T> - constexpr decltype(auto) operator()(T&& ...t) const { - return detail::variadic::foldl1( - static_cast<F&&>(f), - static_cast<State&&>(state), - static_cast<T&&>(t)... - ); - } - }; - } - - template <typename T, bool condition> - struct fold_left_impl<T, when<condition>> : default_ { - // with state - template <typename Xs, typename S, typename F> - static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { - return hana::unpack(static_cast<Xs&&>(xs), - detail::variadic_foldl1<F, S>{f, s} - ); - } - - // without state - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - return hana::unpack(static_cast<Xs&&>(xs), - hana::partial( - detail::variadic::foldl1, - static_cast<F&&>(f) - ) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fold_right.hpp b/contrib/restricted/boost/boost/hana/fold_right.hpp deleted file mode 100644 index 73bdc6f88d..0000000000 --- a/contrib/restricted/boost/boost/hana/fold_right.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*! -@file -Defines `boost::hana::fold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FOLD_RIGHT_HPP -#define BOOST_HANA_FOLD_RIGHT_HPP - -#include <boost/hana/fwd/fold_right.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/variadic/foldr1.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/fwd/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename State, typename F> - constexpr decltype(auto) fold_right_t::operator()(Xs&& xs, State&& state, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using FoldRight = BOOST_HANA_DISPATCH_IF(fold_right_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::fold_right(xs, state, f) requires 'xs' to be Foldable"); - #endif - - return FoldRight::apply(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - - template <typename Xs, typename F> - constexpr decltype(auto) fold_right_t::operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using FoldRight = BOOST_HANA_DISPATCH_IF(fold_right_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::fold_right(xs, f) requires 'xs' to be Foldable"); - #endif - - return FoldRight::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - namespace detail { - template <typename F, typename State> - struct variadic_foldr { - F& f; - State& state; - template <typename ...T> - constexpr decltype(auto) operator()(T&& ...t) const { - return detail::variadic::foldr( - static_cast<F&&>(f), - static_cast<State&&>(state), - static_cast<T&&>(t)... - ); - } - }; - } - - template <typename T, bool condition> - struct fold_right_impl<T, when<condition>> : default_ { - // with state - template <typename Xs, typename S, typename F> - static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { - return hana::unpack(static_cast<Xs&&>(xs), - detail::variadic_foldr<F, S>{f, s} - ); - } - - // without state - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - return hana::unpack(static_cast<Xs&&>(xs), - hana::partial( - detail::variadic::foldr1, - static_cast<F&&>(f) - ) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/for_each.hpp b/contrib/restricted/boost/boost/hana/for_each.hpp deleted file mode 100644 index defc1de4ad..0000000000 --- a/contrib/restricted/boost/boost/hana/for_each.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Defines `boost::hana::for_each`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FOR_EACH_HPP -#define BOOST_HANA_FOR_EACH_HPP - -#include <boost/hana/fwd/for_each.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr void for_each_t::operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using ForEach = BOOST_HANA_DISPATCH_IF(for_each_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::for_each(xs, f) requires 'xs' to be Foldable"); - #endif - - return ForEach::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - namespace detail { - template <typename F> - struct on_each { - F f; - template <typename ...Xs> - constexpr void operator()(Xs&& ...xs) const { - using Swallow = int[]; - (void)Swallow{0, ((void)(*f)(static_cast<Xs&&>(xs)), 0)...}; - } - }; - } - - template <typename T, bool condition> - struct for_each_impl<T, when<condition>> : default_ { - template <typename Xs, typename F> - static constexpr void apply(Xs&& xs, F&& f) { - // We use a pointer instead of a reference to avoid a Clang ICE. - hana::unpack(static_cast<Xs&&>(xs), - detail::on_each<decltype(&f)>{&f}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FOR_EACH_HPP diff --git a/contrib/restricted/boost/boost/hana/front.hpp b/contrib/restricted/boost/boost/hana/front.hpp deleted file mode 100644 index 96d7651a66..0000000000 --- a/contrib/restricted/boost/boost/hana/front.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Defines `boost::hana::front`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FRONT_HPP -#define BOOST_HANA_FRONT_HPP - -#include <boost/hana/fwd/front.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr decltype(auto) front_t::operator()(Xs&& xs) const { - using It = typename hana::tag_of<Xs>::type; - using Front = BOOST_HANA_DISPATCH_IF(front_impl<It>, - hana::Iterable<It>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::front(xs) requires 'xs' to be an Iterable"); - #endif - - return Front::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename It, bool condition> - struct front_impl<It, when<condition>> : default_ { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) - { return hana::at_c<0>(static_cast<Xs&&>(xs)); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/functional.hpp b/contrib/restricted/boost/boost/hana/functional.hpp deleted file mode 100644 index 8f649431b1..0000000000 --- a/contrib/restricted/boost/boost/hana/functional.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Defines the @ref group-functional module. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_HPP -#define BOOST_HANA_FUNCTIONAL_HPP - -#include <boost/hana/functional/always.hpp> -#include <boost/hana/functional/apply.hpp> -#include <boost/hana/functional/arg.hpp> -#include <boost/hana/functional/capture.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/functional/curry.hpp> -#include <boost/hana/functional/demux.hpp> -#include <boost/hana/functional/fix.hpp> -#include <boost/hana/functional/flip.hpp> -#include <boost/hana/functional/id.hpp> -#include <boost/hana/functional/infix.hpp> -#include <boost/hana/functional/iterate.hpp> -#include <boost/hana/functional/lockstep.hpp> -#include <boost/hana/functional/on.hpp> -#include <boost/hana/functional/overload.hpp> -#include <boost/hana/functional/overload_linearly.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/functional/placeholder.hpp> -#include <boost/hana/functional/reverse_partial.hpp> - -#endif // !BOOST_HANA_FUNCTIONAL_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/always.hpp b/contrib/restricted/boost/boost/hana/functional/always.hpp deleted file mode 100644 index df41b851e7..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/always.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/*! -@file -Defines `boost::hana::always`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_ALWAYS_HPP -#define BOOST_HANA_FUNCTIONAL_ALWAYS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Return a constant function returning `x` regardless of the - //! argument(s) it is invoked with. - //! - //! Specifically, `always(x)` is a function such that - //! @code - //! always(x)(y...) == x - //! @endcode - //! for any `y...`. A copy of `x` is made and it is owned by the - //! `always(x)` function. When `always(x)` is called, it will return - //! a reference to the `x` it owns. This reference is valid as long - //! as `always(x)` is in scope. - //! - //! - //! ### Example - //! @include example/functional/always.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto always = [](auto&& x) { - return [perfect-capture](auto const& ...y) -> decltype(auto) { - return forwarded(x); - }; - }; -#else - template <typename T> - struct _always { - T val_; - - template <typename ...Args> - constexpr T const& operator()(Args const& ...) const& - { return val_; } - - template <typename ...Args> - constexpr T& operator()(Args const& ...) & - { return val_; } - - template <typename ...Args> - constexpr T operator()(Args const& ...) && - { return std::move(val_); } - }; - - constexpr detail::create<_always> always{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_ALWAYS_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/apply.hpp b/contrib/restricted/boost/boost/hana/functional/apply.hpp deleted file mode 100644 index 8a47a873e6..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/apply.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Defines `boost::hana::apply`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_APPLY_HPP -#define BOOST_HANA_FUNCTIONAL_APPLY_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Invokes a Callable with the given arguments. - //! - //! This is equivalent to [std::invoke][1] that will be added in C++17. - //! However, `apply` is a function object instead of a function, which - //! makes it possible to pass it to higher-order algorithms. - //! - //! - //! @param f - //! A [Callable][2] to be invoked with the given arguments. - //! - //! @param x... - //! The arguments to call `f` with. The number of `x...` must match the - //! arity of `f`. - //! - //! - //! Example - //! ------- - //! @include example/functional/apply.cpp - //! - //! [1]: http://en.cppreference.com/w/cpp/utility/functional/invoke - //! [2]: http://en.cppreference.com/w/cpp/concept/Callable -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto apply = [](auto&& f, auto&& ...x) -> decltype(auto) { - return forwarded(f)(forwarded(x)...); - }; -#else - struct apply_t { - template <typename F, typename... Args> - constexpr auto operator()(F&& f, Args&&... args) const -> - decltype(static_cast<F&&>(f)(static_cast<Args&&>(args)...)) - { - return static_cast<F&&>(f)(static_cast<Args&&>(args)...); - } - - template <typename Base, typename T, typename Derived> - constexpr auto operator()(T Base::*pmd, Derived&& ref) const -> - decltype(static_cast<Derived&&>(ref).*pmd) - { - return static_cast<Derived&&>(ref).*pmd; - } - - template <typename PMD, typename Pointer> - constexpr auto operator()(PMD pmd, Pointer&& ptr) const -> - decltype((*static_cast<Pointer&&>(ptr)).*pmd) - { - return (*static_cast<Pointer&&>(ptr)).*pmd; - } - - template <typename Base, typename T, typename Derived, typename... Args> - constexpr auto operator()(T Base::*pmf, Derived&& ref, Args&&... args) const -> - decltype((static_cast<Derived&&>(ref).*pmf)(static_cast<Args&&>(args)...)) - { - return (static_cast<Derived&&>(ref).*pmf)(static_cast<Args&&>(args)...); - } - - template <typename PMF, typename Pointer, typename... Args> - constexpr auto operator()(PMF pmf, Pointer&& ptr, Args&& ...args) const -> - decltype(((*static_cast<Pointer&&>(ptr)).*pmf)(static_cast<Args&&>(args)...)) - { - return ((*static_cast<Pointer&&>(ptr)).*pmf)(static_cast<Args&&>(args)...); - } - }; - - constexpr apply_t apply{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_APPLY_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/arg.hpp b/contrib/restricted/boost/boost/hana/functional/arg.hpp deleted file mode 100644 index 5dd5658eff..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/arg.hpp +++ /dev/null @@ -1,141 +0,0 @@ -/*! -@file -Defines `boost::hana::arg`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_ARG_HPP -#define BOOST_HANA_FUNCTIONAL_ARG_HPP - -#include <boost/hana/config.hpp> - -#include <cstddef> -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Return the `n`th passed argument. - //! - //! Specifically, `arg<n>(x1, ..., xn, ..., xm)` is equivalent to `xn`. - //! Note that indexing starts at 1, so `arg<1>` returns the 1st argument, - //! `arg<2>` the 2nd and so on. Using `arg<0>` is an error. Passing - //! less than `n` arguments to `arg<n>` is also an error. - //! - //! - //! @tparam n - //! An unsigned integer representing the argument to return. `n` must be - //! positive (meaning nonzero). - //! - //! @param x1, ..., xm - //! A variadic pack of arguments from which the `n`th one is returned. - //! - //! - //! @internal - //! ### Discussion: could `n` be dynamic? - //! We could have chosen `arg` to be used like `arg(n)(x...)` instead of - //! `arg<n>(x...)`. Provided all the arguments were of the same type, it - //! would then be possible for `n` to only be known at runtime. However, - //! we would then lose the ability to assert the in-boundedness of `n` - //! statically. - //! - //! ### Rationale for `n` being a non-type template parameter - //! I claim that the only interesting use case is with a compile-time - //! `n`, which means that the usage would become `arg(int_<n>)(x...)`, - //! which is more cumbersome to write than `arg<n>(x...)`. This is open - //! for discussion. - //! @endinternal - //! - //! ### Example - //! @include example/functional/arg.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto arg = [](auto&& x1, ..., auto&& xm) -> decltype(auto) { - return forwarded(xn); - }; -#else - template <std::size_t n, typename = void> - struct arg_t; - - template <> - struct arg_t<1> { - template <typename X1, typename ...Xn> - constexpr X1 operator()(X1&& x1, Xn&& ...) const - { return static_cast<X1&&>(x1); } - }; - - template <> - struct arg_t<2> { - template <typename X1, typename X2, typename ...Xn> - constexpr X2 operator()(X1&&, X2&& x2, Xn&& ...) const - { return static_cast<X2&&>(x2); } - }; - - template <> - struct arg_t<3> { - template <typename X1, typename X2, typename X3, typename ...Xn> - constexpr X3 operator()(X1&&, X2&&, X3&& x3, Xn&& ...) const - { return static_cast<X3&&>(x3); } - }; - - template <> - struct arg_t<4> { - template <typename X1, typename X2, typename X3, typename X4, typename ...Xn> - constexpr X4 operator()(X1&&, X2&&, X3&&, X4&& x4, Xn&& ...) const - { return static_cast<X4&&>(x4); } - }; - - template <> - struct arg_t<5> { - template <typename X1, typename X2, typename X3, typename X4, - typename X5, typename ...Xn> - constexpr X5 operator()(X1&&, X2&&, X3&&, X4&&, X5&& x5, Xn&& ...) const - { return static_cast<X5&&>(x5); } - }; - - template <std::size_t n, typename> - struct arg_t { - static_assert(n > 0, - "invalid usage of boost::hana::arg<n> with n == 0"); - - template <typename X1, typename X2, typename X3, typename X4, - typename X5, typename ...Xn> - constexpr decltype(auto) - operator()(X1&&, X2&&, X3&&, X4&&, X5&&, Xn&& ...xn) const { - static_assert(sizeof...(xn) >= n - 5, - "invalid usage of boost::hana::arg<n> with too few arguments"); - - // Since compilers will typically try to continue for a bit after - // an error/static assertion, we must avoid sending the compiler - // in a very long computation if n == 0. - return arg_t<n == 0 ? 1 : n - 5>{}(static_cast<Xn&&>(xn)...); - } - }; - - template <std::size_t n> - struct arg_t<n, std::enable_if_t<(n > 25)>> { - template < - typename X1, typename X2, typename X3, typename X4, typename X5, - typename X6, typename X7, typename X8, typename X9, typename X10, - typename X11, typename X12, typename X13, typename X14, typename X15, - typename X16, typename X17, typename X18, typename X19, typename X20, - typename X21, typename X22, typename X23, typename X24, typename X25, - typename ...Xn> - constexpr decltype(auto) - operator()(X1&&, X2&&, X3&&, X4&&, X5&&, - X6&&, X7&&, X8&&, X9&&, X10&&, - X11&&, X12&&, X13&&, X14&&, X15&&, - X16&&, X17&&, X18&&, X19&&, X20&&, - X21&&, X22&&, X23&&, X24&&, X25&&, Xn&& ...xn) const - { return arg_t<n - 25>{}(static_cast<Xn&&>(xn)...); } - }; - - template <std::size_t n> - constexpr arg_t<n> arg{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_ARG_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/capture.hpp b/contrib/restricted/boost/boost/hana/functional/capture.hpp deleted file mode 100644 index 65b4675833..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/capture.hpp +++ /dev/null @@ -1,112 +0,0 @@ -/*! -@file -Defines `boost::hana::capture`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_CAPTURE_HPP -#define BOOST_HANA_FUNCTIONAL_CAPTURE_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/functional/partial.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Create a function capturing the given variables. - //! - //! Given 0 or more variables, `capture` creates a closure that can be - //! used to partially apply a function. This is very similar to `partial`, - //! except that `capture` allows the partially applied function to be - //! specified later. Specifically, `capture(vars...)` is a function object - //! taking a function `f` and returning `f` partially applied to `vars...`. - //! In other words, - //! @code - //! capture(vars...)(f)(args...) == f(vars..., args...) - //! @endcode - //! - //! @note - //! The arity of `f` must match the total number of arguments passed to - //! it, i.e. `sizeof...(vars) + sizeof...(args)`. - //! - //! - //! Example - //! ------- - //! @include example/functional/capture.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto capture = [](auto&& ...variables) { - return [perfect-capture](auto&& f) { - return [perfect-capture](auto&& ...args) -> decltype(auto) { - return forwarded(f)(forwarded(variables)..., forwarded(args)...); - }; - }; - }; -#else - namespace detail { - template <typename F, typename Closure, std::size_t ...i> - constexpr auto apply_capture(F&& f, Closure&& closure, std::index_sequence<i...>) { - return hana::partial(static_cast<F&&>(f), - hana::at_c<i>(static_cast<Closure&&>(closure).storage_)... - ); - } - } - - template <typename ...X> - struct capture_t; - - struct make_capture_t { - struct secret { }; - template <typename ...X> - constexpr capture_t<typename detail::decay<X>::type...> - operator()(X&& ...x) const { - return {secret{}, static_cast<X&&>(x)...}; - } - }; - - template <typename ...X> - struct capture_t { - template <typename ...Y> - constexpr capture_t(make_capture_t::secret, Y&& ...y) - : storage_{static_cast<Y&&>(y)...} - { } - - basic_tuple<X...> storage_; - - template <typename F> - constexpr auto operator()(F&& f) const& { - return detail::apply_capture( - static_cast<F&&>(f), *this, - std::make_index_sequence<sizeof...(X)>{} - ); - } - - template <typename F> - constexpr auto operator()(F&& f) & { - return detail::apply_capture( - static_cast<F&&>(f), *this, - std::make_index_sequence<sizeof...(X)>{} - ); - } - - template <typename F> - constexpr auto operator()(F&& f) && { - return detail::apply_capture( - static_cast<F&&>(f), static_cast<capture_t&&>(*this), - std::make_index_sequence<sizeof...(X)>{} - ); - } - }; - - constexpr make_capture_t capture{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_CAPTURE_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/compose.hpp b/contrib/restricted/boost/boost/hana/functional/compose.hpp deleted file mode 100644 index bbc53f6ff4..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/compose.hpp +++ /dev/null @@ -1,108 +0,0 @@ -/*! -@file -Defines `boost::hana::compose`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_COMPOSE_HPP -#define BOOST_HANA_FUNCTIONAL_COMPOSE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> -#include <boost/hana/detail/variadic/foldl1.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Return the composition of two functions or more. - //! - //! `compose` is defined inductively. When given more than two functions, - //! `compose(f, g, h...)` is equivalent to `compose(f, compose(g, h...))`. - //! When given two functions, `compose(f, g)` is a function such that - //! @code - //! compose(f, g)(x, y...) == f(g(x), y...) - //! @endcode - //! - //! If you need composition of the form `f(g(x, y...))`, use `demux` instead. - //! - //! @note - //! `compose` is an associative operation; `compose(f, compose(g, h))` - //! is equivalent to `compose(compose(f, g), h)`. - //! - //! @internal - //! ### Proof of associativity - //! - //! @code - //! compose(f, compose(g, h))(x, xs...) == f(compose(g, h)(x), xs...) - //! == f(g(h(x)), xs...) - //! - //! compose(compose(f, g), h)(x, xs...) == compose(f, g)(h(x), xs...) - //! == f(g(h(x)), xs...) - //! @endcode - //! @endinternal - //! - //! ### Example - //! @include example/functional/compose.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto compose = [](auto&& f1, auto&& f2, ..., auto&& fn) { - return [perfect-capture](auto&& x, auto&& ...xs) -> decltype(auto) { - return forwarded(f1)( - forwarded(f2)( - ... - forwarded(fn)(forwarded(x)) - ), - forwarded(xs)... - ); - } - }; -#else - template <typename F, typename G> - struct _compose { - F f; G g; - - template <typename X, typename ...Xs> - constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) const& { - return f( - g(static_cast<X&&>(x)), - static_cast<Xs&&>(xs)... - ); - } - - template <typename X, typename ...Xs> - constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) & { - return f( - g(static_cast<X&&>(x)), - static_cast<Xs&&>(xs)... - ); - } - - template <typename X, typename ...Xs> - constexpr decltype(auto) operator()(X&& x, Xs&& ...xs) && { - return std::move(f)( - std::move(g)(static_cast<X&&>(x)), - static_cast<Xs&&>(xs)... - ); - } - }; - - struct _make_compose { - template <typename F, typename G, typename ...H> - constexpr decltype(auto) operator()(F&& f, G&& g, H&& ...h) const { - return detail::variadic::foldl1(detail::create<_compose>{}, - static_cast<F&&>(f), - static_cast<G&&>(g), - static_cast<H&&>(h)... - ); - } - }; - - constexpr _make_compose compose{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_COMPOSE_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/curry.hpp b/contrib/restricted/boost/boost/hana/functional/curry.hpp deleted file mode 100644 index 762718c208..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/curry.hpp +++ /dev/null @@ -1,170 +0,0 @@ -/*! -@file -Defines `boost::hana::curry`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_CURRY_HPP -#define BOOST_HANA_FUNCTIONAL_CURRY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/functional/apply.hpp> -#include <boost/hana/functional/partial.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Curry a function up to the given number of arguments. - //! - //! [Currying][Wikipedia.currying] is a technique in which we consider a - //! function taking multiple arguments (or, equivalently, a tuple of - //! arguments), and turn it into a function which takes a single argument - //! and returns a function to handle the remaining arguments. To help - //! visualize, let's denote the type of a function `f` which takes - //! arguments of types `X1, ..., Xn` and returns a `R` as - //! @code - //! (X1, ..., Xn) -> R - //! @endcode - //! - //! Then, currying is the process of taking `f` and turning it into an - //! equivalent function (call it `g`) of type - //! @code - //! X1 -> (X2 -> (... -> (Xn -> R))) - //! @endcode - //! - //! This gives us the following equivalence, where `x1`, ..., `xn` are - //! objects of type `X1`, ..., `Xn` respectively: - //! @code - //! f(x1, ..., xn) == g(x1)...(xn) - //! @endcode - //! - //! Currying can be useful in several situations, especially when working - //! with higher-order functions. - //! - //! This `curry` utility is an implementation of currying in C++. - //! Specifically, `curry<n>(f)` is a function such that - //! @code - //! curry<n>(f)(x1)...(xn) == f(x1, ..., xn) - //! @endcode - //! - //! Note that the `n` has to be specified explicitly because the existence - //! of functions with variadic arguments in C++ make it impossible to know - //! when currying should stop. - //! - //! Unlike usual currying, this implementation also allows a curried - //! function to be called with several arguments at a time. Hence, the - //! following always holds - //! @code - //! curry<n>(f)(x1, ..., xk) == curry<n - k>(f)(x1)...(xk) - //! @endcode - //! - //! Of course, this requires `k` to be less than or equal to `n`; failure - //! to satisfy this will trigger a static assertion. This syntax is - //! supported because it makes curried functions usable where normal - //! functions are expected. - //! - //! Another "extension" is that `curry<0>(f)` is supported: `curry<0>(f)` - //! is a nullary function; whereas the classical definition for currying - //! seems to leave this case undefined, as nullary functions don't make - //! much sense in purely functional languages. - //! - //! - //! Example - //! ------- - //! @include example/functional/curry.cpp - //! - //! - //! [Wikipedia.currying]: http://en.wikipedia.org/wiki/Currying -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto curry = [](auto&& f) { - return [perfect-capture](auto&& x1) { - return [perfect-capture](auto&& x2) { - ... - return [perfect-capture](auto&& xn) -> decltype(auto) { - return forwarded(f)( - forwarded(x1), forwarded(x2), ..., forwarded(xn) - ); - }; - }; - }; - }; -#else - template <std::size_t n, typename F> - struct curry_t; - - template <std::size_t n> - struct make_curry_t { - template <typename F> - constexpr curry_t<n, typename detail::decay<F>::type> - operator()(F&& f) const { return {static_cast<F&&>(f)}; } - }; - - template <std::size_t n> - constexpr make_curry_t<n> curry{}; - - namespace curry_detail { namespace { - template <std::size_t n> - constexpr make_curry_t<n> curry_or_call{}; - - template <> - constexpr auto curry_or_call<0> = apply; - }} - - template <std::size_t n, typename F> - struct curry_t { - F f; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& { - static_assert(sizeof...(x) <= n, - "too many arguments provided to boost::hana::curry"); - return curry_detail::curry_or_call<n - sizeof...(x)>( - partial(f, static_cast<X&&>(x)...) - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & { - static_assert(sizeof...(x) <= n, - "too many arguments provided to boost::hana::curry"); - return curry_detail::curry_or_call<n - sizeof...(x)>( - partial(f, static_cast<X&&>(x)...) - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && { - static_assert(sizeof...(x) <= n, - "too many arguments provided to boost::hana::curry"); - return curry_detail::curry_or_call<n - sizeof...(x)>( - partial(std::move(f), static_cast<X&&>(x)...) - ); - } - }; - - template <typename F> - struct curry_t<0, F> { - F f; - - constexpr decltype(auto) operator()() const& - { return f(); } - - constexpr decltype(auto) operator()() & - { return f(); } - - constexpr decltype(auto) operator()() && - { return std::move(f)(); } - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_CURRY_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/demux.hpp b/contrib/restricted/boost/boost/hana/functional/demux.hpp deleted file mode 100644 index f76b68ed48..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/demux.hpp +++ /dev/null @@ -1,269 +0,0 @@ -/*! -@file -Defines `boost::hana::demux`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_DEMUX_HPP -#define BOOST_HANA_FUNCTIONAL_DEMUX_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Invoke a function with the results of invoking other functions - //! on its arguments. - //! - //! Specifically, `demux(f)(g...)` is a function such that - //! @code - //! demux(f)(g...)(x...) == f(g(x...)...) - //! @endcode - //! - //! Each `g` is called with all the arguments, and then `f` is called - //! with the result of each `g`. Hence, the arity of `f` must match - //! the number of `g`s. - //! - //! This is called `demux` because of a vague similarity between this - //! device and a demultiplexer in signal processing. `demux` takes what - //! can be seen as a continuation (`f`), a bunch of functions to split a - //! signal (`g...`) and zero or more arguments representing the signal - //! (`x...`). Then, it calls the continuation with the result of - //! splitting the signal with whatever functions where given. - //! - //! @note - //! When used with two functions only, `demux` is associative. In other - //! words (and noting `demux(f, g) = demux(f)(g)` to ease the notation), - //! it is true that `demux(demux(f, g), h) == demux(f, demux(g, h))`. - //! - //! - //! Signature - //! --------- - //! The signature of `demux` is - //! \f[ - //! \mathtt{demux} : - //! (B_1 \times \dotsb \times B_n \to C) - //! \to ((A_1 \times \dotsb \times A_n \to B_1) - //! \times \dotsb - //! \times (A_1 \times \dotsb \times A_n \to B_n)) - //! \to (A_1 \times \dotsb \times A_n \to C) - //! \f] - //! - //! This can be rewritten more tersely as - //! \f[ - //! \mathtt{demux} : - //! \left(\prod_{i=1}^n B_i \to C \right) - //! \to \prod_{j=1}^n \left(\prod_{i=1}^n A_i \to B_j \right) - //! \to \left(\prod_{i=1}^n A_i \to C \right) - //! \f] - //! - //! - //! Link with normal composition - //! ---------------------------- - //! The signature of `compose` is - //! \f[ - //! \mathtt{compose} : (B \to C) \times (A \to B) \to (A \to C) - //! \f] - //! - //! A valid observation is that this coincides exactly with the type - //! of `demux` when used with a single unary function. Actually, both - //! functions are equivalent: - //! @code - //! demux(f)(g)(x) == compose(f, g)(x) - //! @endcode - //! - //! However, let's now consider the curried version of `compose`, - //! `curry<2>(compose)`: - //! \f[ - //! \mathtt{curry_2(compose)} : (B \to C) \to ((A \to B) \to (A \to C)) - //! \f] - //! - //! For the rest of this explanation, we'll just consider the curried - //! version of `compose` and so we'll use `compose` instead of - //! `curry<2>(compose)` to lighten the notation. With currying, we can - //! now consider `compose` applied to itself: - //! \f[ - //! \mathtt{compose(compose, compose)} : - //! (B \to C) \to (A_1 \to A_2 \to B) \to (A_1 \to A_2 \to C) - //! \f] - //! - //! If we uncurry deeply the above expression, we obtain - //! \f[ - //! \mathtt{compose(compose, compose)} : - //! (B \to C) \times (A_1 \times A_2 \to B) \to (A_1 \times A_2 \to C) - //! \f] - //! - //! This signature is exactly the same as that of `demux` when given a - //! single binary function, and indeed they are equivalent definitions. - //! We can also generalize this further by considering - //! `compose(compose(compose, compose), compose)`: - //! \f[ - //! \mathtt{compose(compose(compose, compose), compose)} : - //! (B \to C) \to (A_1 \to A_2 \to A_3 \to B) - //! \to (A_1 \to A_2 \to A_3 \to C) - //! \f] - //! - //! which uncurries to - //! \f[ - //! \mathtt{compose(compose(compose, compose), compose)} : - //! (B \to C) \times (A_1 \times A_2 \times A_3 \to B) - //! \to (A_1 \times A_2 \times A_3 \to C) - //! \f] - //! - //! This signature is exactly the same as that of `demux` when given a - //! single ternary function. Hence, for a single n-ary function `g`, - //! `demux(f)(g)` is equivalent to the n-times composition of `compose` - //! with itself, applied to `g` and `f`: - //! @code - //! demux(f)(g) == fold_left([compose, ..., compose], id, compose)(g, f) - //! // ^^^^^^^^^^^^^^^^^^^^^ n times - //! @endcode - //! - //! More information on this insight can be seen [here][1]. Also, I'm - //! not sure how this insight could be generalized to more than one - //! function `g`, or if that is even possible. - //! - //! - //! Proof of associativity in the binary case - //! ----------------------------------------- - //! As explained above, `demux` is associative when it is used with - //! two functions only. Indeed, given functions `f`, `g` and `h` with - //! suitable signatures, we have - //! @code - //! demux(f)(demux(g)(h))(x...) == f(demux(g)(h)(x...)) - //! == f(g(h(x...))) - //! @endcode - //! - //! On the other hand, we have - //! @code - //! demux(demux(f)(g))(h)(x...) == demux(f)(g)(h(x...)) - //! == f(g(h(x...))) - //! @endcode - //! - //! and hence `demux` is associative in the binary case. - //! - //! - //! Example - //! ------- - //! @include example/functional/demux.cpp - //! - //! [1]: http://stackoverflow.com/q/5821089/627587 -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto demux = [](auto&& f) { - return [perfect-capture](auto&& ...g) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - // x... can't be forwarded unless there is a single g - // function, or that could cause double-moves. - return forwarded(f)(forwarded(g)(x...)...); - }; - }; - }; -#else - template <typename F> - struct pre_demux_t; - - struct make_pre_demux_t { - struct secret { }; - template <typename F> - constexpr pre_demux_t<typename detail::decay<F>::type> operator()(F&& f) const { - return {static_cast<F&&>(f)}; - } - }; - - template <typename Indices, typename F, typename ...G> - struct demux_t; - - template <typename F> - struct pre_demux_t { - F f; - - template <typename ...G> - constexpr demux_t<std::make_index_sequence<sizeof...(G)>, F, - typename detail::decay<G>::type...> - operator()(G&& ...g) const& { - return {make_pre_demux_t::secret{}, this->f, static_cast<G&&>(g)...}; - } - - template <typename ...G> - constexpr demux_t<std::make_index_sequence<sizeof...(G)>, F, - typename detail::decay<G>::type...> - operator()(G&& ...g) && { - return {make_pre_demux_t::secret{}, static_cast<F&&>(this->f), static_cast<G&&>(g)...}; - } - }; - - template <std::size_t ...n, typename F, typename ...G> - struct demux_t<std::index_sequence<n...>, F, G...> { - template <typename ...T> - constexpr demux_t(make_pre_demux_t::secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, G...> storage_; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)(x...)... - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)(x...)... - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && { - return static_cast<F&&>(hana::at_c<0>(storage_))( - static_cast<G&&>(hana::at_c<n+1>(storage_))(x...)... - ); - } - }; - - template <typename F, typename G> - struct demux_t<std::index_sequence<0>, F, G> { - template <typename ...T> - constexpr demux_t(make_pre_demux_t::secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, G> storage_; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& { - return hana::at_c<0>(storage_)( - hana::at_c<1>(storage_)(static_cast<X&&>(x)...) - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & { - return hana::at_c<0>(storage_)( - hana::at_c<1>(storage_)(static_cast<X&&>(x)...) - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && { - return static_cast<F&&>(hana::at_c<0>(storage_))( - static_cast<G&&>(hana::at_c<1>(storage_))(static_cast<X&&>(x)...) - ); - } - }; - - constexpr make_pre_demux_t demux{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_DEMUX_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/fix.hpp b/contrib/restricted/boost/boost/hana/functional/fix.hpp deleted file mode 100644 index 4c636ee10b..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/fix.hpp +++ /dev/null @@ -1,83 +0,0 @@ -/*! -@file -Defines `boost::hana::fix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_FIX_HPP -#define BOOST_HANA_FUNCTIONAL_FIX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Return a function computing the fixed point of a function. - //! - //! `fix` is an implementation of the [Y-combinator][], also called the - //! fixed-point combinator. It encodes the idea of recursion, and in fact - //! any recursive function can be written in terms of it. - //! - //! Specifically, `fix(f)` is a function such that - //! @code - //! fix(f)(x...) == f(fix(f), x...) - //! @endcode - //! - //! This definition allows `f` to use its first argument as a continuation - //! to call itself recursively. Indeed, if `f` calls its first argument - //! with `y...`, it is equivalent to calling `f(fix(f), y...)` per the - //! above equation. - //! - //! Most of the time, it is more convenient and efficient to define - //! recursive functions without using a fixed-point combinator. However, - //! there are some cases where `fix` provides either more flexibility - //! (e.g. the ability to change the callback inside `f`) or makes it - //! possible to write functions that couldn't be defined recursively - //! otherwise. - //! - //! @param f - //! A function called as `f(self, x...)`, where `x...` are the arguments - //! in the `fix(f)(x...)` expression and `self` is `fix(f)`. - //! - //! ### Example - //! @include example/functional/fix.cpp - //! - //! [Y-combinator]: http://en.wikipedia.org/wiki/Fixed-point_combinator -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto fix = [](auto&& f) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - return forwarded(f)(fix(f), forwarded(x)...); - }; - }; -#else - template <typename F> - struct fix_t; - - constexpr detail::create<fix_t> fix{}; - - template <typename F> - struct fix_t { - F f; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& - { return f(fix(f), static_cast<X&&>(x)...); } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & - { return f(fix(f), static_cast<X&&>(x)...); } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && - { return std::move(f)(fix(f), static_cast<X&&>(x)...); } - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_FIX_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/flip.hpp b/contrib/restricted/boost/boost/hana/functional/flip.hpp deleted file mode 100644 index d896f5e8d3..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/flip.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*! -@file -Defines `boost::hana::flip`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_FLIP_HPP -#define BOOST_HANA_FUNCTIONAL_FLIP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Invoke a function with its two first arguments reversed. - //! - //! Specifically, `flip(f)` is a function such that - //! @code - //! flip(f)(x, y, z...) == f(y, x, z...) - //! @endcode - //! - //! ### Example - //! @include example/functional/flip.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto flip = [](auto&& f) { - return [perfect-capture](auto&& x, auto&& y, auto&& ...z) -> decltype(auto) { - return forwarded(f)(forwarded(y), forwarded(x), forwarded(z)...); - }; - }; -#else - template <typename F> - struct flip_t { - F f; - - template <typename X, typename Y, typename ...Z> - constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) const& { - return f( - static_cast<Y&&>(y), - static_cast<X&&>(x), - static_cast<Z&&>(z)... - ); - } - - template <typename X, typename Y, typename ...Z> - constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) & { - return f( - static_cast<Y&&>(y), - static_cast<X&&>(x), - static_cast<Z&&>(z)... - ); - } - - template <typename X, typename Y, typename ...Z> - constexpr decltype(auto) operator()(X&& x, Y&& y, Z&& ...z) && { - return std::move(f)( - static_cast<Y&&>(y), - static_cast<X&&>(x), - static_cast<Z&&>(z)... - ); - } - }; - - constexpr detail::create<flip_t> flip{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_FLIP_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/id.hpp b/contrib/restricted/boost/boost/hana/functional/id.hpp deleted file mode 100644 index 04c9443b94..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/id.hpp +++ /dev/null @@ -1,38 +0,0 @@ -/*! -@file -Defines `boost::hana::id`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_ID_HPP -#define BOOST_HANA_FUNCTIONAL_ID_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! The identity function -- returns its argument unchanged. - //! - //! ### Example - //! @include example/functional/id.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto id = [](auto&& x) -> decltype(auto) { - return forwarded(x); - }; -#else - struct id_t { - template <typename T> - constexpr T operator()(T&& t) const { - return static_cast<T&&>(t); - } - }; - - constexpr id_t id{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_ID_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/infix.hpp b/contrib/restricted/boost/boost/hana/functional/infix.hpp deleted file mode 100644 index 7b5d82cbe0..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/infix.hpp +++ /dev/null @@ -1,185 +0,0 @@ -/*! -@file -Defines `boost::hana::infix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_INFIX_HPP -#define BOOST_HANA_FUNCTIONAL_INFIX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/functional/reverse_partial.hpp> - -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Return an equivalent function that can also be applied in infix - //! notation. - //! - //! Specifically, `infix(f)` is an object such that: - //! @code - //! infix(f)(x1, ..., xn) == f(x1, ..., xn) - //! x ^infix(f)^ y == f(x, y) - //! @endcode - //! - //! Hence, the returned function can still be applied using the usual - //! function call syntax, but it also gains the ability to be applied in - //! infix notation. The infix syntax allows a great deal of expressiveness, - //! especially when used in combination with some higher order algorithms. - //! Since `operator^` is left-associative, `x ^infix(f)^ y` is actually - //! parsed as `(x ^infix(f))^ y`. However, for flexibility, the order in - //! which both arguments are applied in infix notation does not matter. - //! Hence, it is always the case that - //! @code - //! (x ^ infix(f)) ^ y == x ^ (infix(f) ^ y) - //! @endcode - //! - //! However, note that applying more than one argument in infix - //! notation to the same side of the operator will result in a - //! compile-time assertion: - //! @code - //! (infix(f) ^ x) ^ y; // compile-time assertion - //! y ^ (x ^ infix(f)); // compile-time assertion - //! @endcode - //! - //! Additionally, a function created with `infix` may be partially applied - //! in infix notation. Specifically, - //! @code - //! (x ^ infix(f))(y1, ..., yn) == f(x, y1, ..., yn) - //! (infix(f) ^ y)(x1, ..., xn) == f(x1, ..., xn, y) - //! @endcode - //! - //! @internal - //! ### Rationales - //! 1. The `^` operator was chosen because it is left-associative and - //! has a low enough priority so that most expressions will render - //! the expected behavior. - //! 2. The operator can't be customimzed because that would require more - //! sophistication in the implementation; I want to keep it as simple - //! as possible. There is also an advantage in having a uniform syntax - //! for infix application. - //! @endinternal - //! - //! @param f - //! The function which gains the ability to be applied in infix notation. - //! The function must be at least binary; a compile-time error will be - //! triggered otherwise. - //! - //! ### Example - //! @include example/functional/infix.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto infix = [](auto f) { - return unspecified; - }; -#else - namespace infix_detail { - // This needs to be in the same namespace as `operator^` so it can be - // found by ADL. - template <bool left, bool right, typename F> - struct infix_t { - F f; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& - { return f(static_cast<X&&>(x)...); } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & - { return f(static_cast<X&&>(x)...); } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && - { return std::move(f)(static_cast<X&&>(x)...); } - }; - - template <bool left, bool right> - struct make_infix { - template <typename F> - constexpr infix_t<left, right, typename detail::decay<F>::type> - operator()(F&& f) const { return {static_cast<F&&>(f)}; } - }; - - template <bool left, bool right> - struct Infix; - struct Object; - - template <typename T> - struct dispatch { using type = Object; }; - - template <bool left, bool right, typename F> - struct dispatch<infix_t<left, right, F>> { - using type = Infix<left, right>; - }; - - template <typename, typename> - struct bind_infix; - - // infix(f) ^ y - template <> - struct bind_infix<Infix<false, false>, Object> { - template <typename F, typename Y> - static constexpr decltype(auto) apply(F&& f, Y&& y) { - return make_infix<false, true>{}( - hana::reverse_partial( - static_cast<F&&>(f), static_cast<Y&&>(y) - ) - ); - } - }; - - // (x^infix(f)) ^ y - template <> - struct bind_infix<Infix<true, false>, Object> { - template <typename F, typename Y> - static constexpr decltype(auto) apply(F&& f, Y&& y) { - return static_cast<F&&>(f)(static_cast<Y&&>(y)); - } - }; - - // x ^ infix(f) - template <> - struct bind_infix<Object, Infix<false, false>> { - template <typename X, typename F> - static constexpr decltype(auto) apply(X&& x, F&& f) { - return make_infix<true, false>{}( - hana::partial(static_cast<F&&>(f), static_cast<X&&>(x)) - ); - } - }; - - // x ^ (infix(f)^y) - template <> - struct bind_infix<Object, Infix<false, true>> { - template <typename X, typename F> - static constexpr decltype(auto) apply(X&& x, F&& f) { - return static_cast<F&&>(f)(static_cast<X&&>(x)); - } - }; - - template <typename T> - using strip = typename std::remove_cv< - typename std::remove_reference<T>::type - >::type; - - template <typename X, typename Y> - constexpr decltype(auto) operator^(X&& x, Y&& y) { - return bind_infix< - typename dispatch<strip<X>>::type, - typename dispatch<strip<Y>>::type - >::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - } // end namespace infix_detail - - constexpr infix_detail::make_infix<false, false> infix{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_INFIX_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/iterate.hpp b/contrib/restricted/boost/boost/hana/functional/iterate.hpp deleted file mode 100644 index 9a4ce3e9b2..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/iterate.hpp +++ /dev/null @@ -1,201 +0,0 @@ -/*! -@file -Defines `boost::hana::iterate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_ITERATE_HPP -#define BOOST_HANA_FUNCTIONAL_ITERATE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/functional/partial.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Applies another function `n` times to its argument. - //! - //! Given a function `f` and an argument `x`, `iterate<n>(f, x)` returns - //! the result of applying `f` `n` times to its argument. In other words, - //! @code - //! iterate<n>(f, x) == f(f( ... f(x))) - //! ^^^^^^^^^^ n times total - //! @endcode - //! - //! If `n == 0`, `iterate<n>(f, x)` returns the `x` argument unchanged - //! and `f` is never applied. It is important to note that the function - //! passed to `iterate<n>` must be a unary function. Indeed, since `f` - //! will be called with the result of the previous `f` application, it - //! may only take a single argument. - //! - //! In addition to what's documented above, `iterate` can also be - //! partially applied to the function argument out-of-the-box. In - //! other words, `iterate<n>(f)` is a function object applying `f` - //! `n` times to the argument it is called with, which means that - //! @code - //! iterate<n>(f)(x) == iterate<n>(f, x) - //! @endcode - //! - //! This is provided for convenience, and it turns out to be especially - //! useful in conjunction with higher-order algorithms. - //! - //! - //! Signature - //! --------- - //! Given a function \f$ f : T \to T \f$ and `x` and argument of data - //! type `T`, the signature is - //! \f$ - //! \mathtt{iterate_n} : (T \to T) \times T \to T - //! \f$ - //! - //! @tparam n - //! An unsigned integer representing the number of times that `f` - //! should be applied to its argument. - //! - //! @param f - //! A function to apply `n` times to its argument. - //! - //! @param x - //! The initial value to call `f` with. - //! - //! - //! Example - //! ------- - //! @include example/functional/iterate.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto iterate = [](auto&& f) { - return [perfect-capture](auto&& x) -> decltype(auto) { - return f(f( ... f(forwarded(x)))); - }; - }; -#else - template <std::size_t n, typename = when<true>> - struct iterate_t; - - template <> - struct iterate_t<0> { - template <typename F, typename X> - constexpr X operator()(F&&, X&& x) const - { return static_cast<X&&>(x); } - }; - - template <> - struct iterate_t<1> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return f(static_cast<X&&>(x)); - } - }; - - template <> - struct iterate_t<2> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return f(f(static_cast<X&&>(x))); - } - }; - - template <> - struct iterate_t<3> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return f(f(f(static_cast<X&&>(x)))); - } - }; - - template <> - struct iterate_t<4> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return f(f(f(f(static_cast<X&&>(x))))); - } - }; - - template <> - struct iterate_t<5> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return f(f(f(f(f(static_cast<X&&>(x)))))); - } - }; - - template <std::size_t n> - struct iterate_t<n, when<(n >= 6) && (n < 12)>> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return iterate_t<n - 6>{}(f, - f(f(f(f(f(f(static_cast<X&&>(x))))))) - ); - } - }; - - template <std::size_t n> - struct iterate_t<n, when<(n >= 12) && (n < 24)>> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return iterate_t<n - 12>{}(f, - f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X&&>(x) - )))))))))))) - ); - } - }; - - template <std::size_t n> - struct iterate_t<n, when<(n >= 24) && (n < 48)>> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return iterate_t<n - 24>{}(f, - f(f(f(f(f(f(f(f(f(f(f(f( - f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X&&>(x) - )))))))))))) - )))))))))))) - ); - } - }; - - template <std::size_t n> - struct iterate_t<n, when<(n >= 48)>> { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return iterate_t<n - 48>{}(f, - f(f(f(f(f(f(f(f(f(f(f(f( - f(f(f(f(f(f(f(f(f(f(f(f( - f(f(f(f(f(f(f(f(f(f(f(f( - f(f(f(f(f(f(f(f(f(f(f(f( - static_cast<X&&>(x) - )))))))))))) - )))))))))))) - )))))))))))) - )))))))))))) - ); - } - }; - - template <std::size_t n> - struct make_iterate_t { - template <typename F> - constexpr decltype(auto) operator()(F&& f) const - { return hana::partial(iterate_t<n>{}, static_cast<F&&>(f)); } - - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const { - return iterate_t<n>{}(static_cast<F&&>(f), - static_cast<X&&>(x)); - } - }; - - template <std::size_t n> - constexpr make_iterate_t<n> iterate{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_ITERATE_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/lockstep.hpp b/contrib/restricted/boost/boost/hana/functional/lockstep.hpp deleted file mode 100644 index 2f60781883..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/lockstep.hpp +++ /dev/null @@ -1,114 +0,0 @@ -/*! -@file -Defines `boost::hana::lockstep`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP -#define BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Invoke a function with the result of invoking other functions on its - //! arguments, in lockstep. - //! - //! Specifically, `lockstep(f)(g1, ..., gN)` is a function such that - //! @code - //! lockstep(f)(g1, ..., gN)(x1, ..., xN) == f(g1(x1), ..., gN(xN)) - //! @endcode - //! - //! Since each `g` is invoked on its corresponding argument in lockstep, - //! the number of arguments must match the number of `g`s. - //! - //! - //! Example - //! ------- - //! @include example/functional/lockstep.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto lockstep = [](auto&& f, auto&& ...g) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - return forwarded(f)(forwarded(g)(forwarded(x))...); - }; - }; -#else - template <typename Indices, typename F, typename ...G> - struct lockstep_t; - - template <typename F> - struct pre_lockstep_t; - - struct make_pre_lockstep_t { - struct secret { }; - template <typename F> - constexpr pre_lockstep_t<typename detail::decay<F>::type> operator()(F&& f) const { - return {static_cast<F&&>(f)}; - } - }; - - template <std::size_t ...n, typename F, typename ...G> - struct lockstep_t<std::index_sequence<n...>, F, G...> { - template <typename ...T> - constexpr lockstep_t(make_pre_lockstep_t::secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, G...> storage_; - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)(static_cast<X&&>(x))... - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)(static_cast<X&&>(x))... - ); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && { - return static_cast<F&&>(hana::at_c<0>(storage_))( - static_cast<G&&>(hana::at_c<n+1>(storage_))(static_cast<X&&>(x))... - ); - } - }; - - template <typename F> - struct pre_lockstep_t { - F f; - - template <typename ...G> - constexpr lockstep_t<std::make_index_sequence<sizeof...(G)>, F, - typename detail::decay<G>::type...> - operator()(G&& ...g) const& { - return {make_pre_lockstep_t::secret{}, this->f, static_cast<G&&>(g)...}; - } - - template <typename ...G> - constexpr lockstep_t<std::make_index_sequence<sizeof...(G)>, F, - typename detail::decay<G>::type...> - operator()(G&& ...g) && { - return {make_pre_lockstep_t::secret{}, static_cast<F&&>(this->f), - static_cast<G&&>(g)...}; - } - }; - - constexpr make_pre_lockstep_t lockstep{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_LOCKSTEP_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/on.hpp b/contrib/restricted/boost/boost/hana/functional/on.hpp deleted file mode 100644 index 59561870a3..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/on.hpp +++ /dev/null @@ -1,83 +0,0 @@ -/*! -@file -Defines `boost::hana::on`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_ON_HPP -#define BOOST_HANA_FUNCTIONAL_ON_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> -#include <boost/hana/functional/infix.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Invoke a function with the result of invoking another function on - //! each argument. - //! - //! Specifically, `on(f, g)` is a function such that - //! @code - //! on(f, g)(x...) == f(g(x)...) - //! @endcode - //! - //! For convenience, `on` also supports infix application as provided - //! by `infix`. - //! - //! - //! @note - //! `on` is associative, i.e. `on(f, on(g, h))` is equivalent to - //! `on(on(f, g), h)`. - //! - //! @internal - //! ### Proof of associativity - //! - //! @code - //! on(f, on(g, h))(xs...) == f(on(g, h)(xs)...) - //! == f(g(h(xs))...) - //! - //! on(on(f, g), h)(xs...) == on(f, g)(h(xs)...) - //! == f(g(h(xs))...) - //! @endcode - //! @endinternal - //! - //! - //! ### Example - //! @include example/functional/on.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto on = infix([](auto&& f, auto&& g) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - return forwarded(f)(g(forwarded(x))...); - }; - }); -#else - template <typename F, typename G> - struct on_t { - F f; G g; - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const& { - return f(g(static_cast<X&&>(x))...); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) & { - return f(g(static_cast<X&&>(x))...); - } - - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) && { - return std::move(f)(g(static_cast<X&&>(x))...); - } - }; - - constexpr auto on = infix(detail::create<on_t>{}); -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_ON_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/overload.hpp b/contrib/restricted/boost/boost/hana/functional/overload.hpp deleted file mode 100644 index d8ce96a5ac..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/overload.hpp +++ /dev/null @@ -1,88 +0,0 @@ -/*! -@file -Defines `boost::hana::overload`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP -#define BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Pick one of several functions to call based on overload resolution. - //! - //! Specifically, `overload(f1, f2, ..., fn)` is a function object such - //! that - //! @code - //! overload(f1, f2, ..., fn)(x...) == fk(x...) - //! @endcode - //! - //! where `fk` is the function of `f1, ..., fn` that would be called if - //! overload resolution was performed amongst that set of functions only. - //! If more than one function `fk` would be picked by overload resolution, - //! then the call is ambiguous. - //! - //! ### Example - //! @include example/functional/overload.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto overload = [](auto&& f1, auto&& f2, ..., auto&& fn) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - return forwarded(fk)(forwarded(x)...); - }; - }; -#else - template <typename F, typename ...G> - struct overload_t - : overload_t<F>::type - , overload_t<G...>::type - { - using type = overload_t; - using overload_t<F>::type::operator(); - using overload_t<G...>::type::operator(); - - template <typename F_, typename ...G_> - constexpr explicit overload_t(F_&& f, G_&& ...g) - : overload_t<F>::type(static_cast<F_&&>(f)) - , overload_t<G...>::type(static_cast<G_&&>(g)...) - { } - }; - - template <typename F> - struct overload_t<F> { using type = F; }; - - template <typename R, typename ...Args> - struct overload_t<R(*)(Args...)> { - using type = overload_t; - R (*fptr_)(Args...); - - explicit constexpr overload_t(R (*fp)(Args...)) - : fptr_(fp) - { } - - constexpr R operator()(Args ...args) const - { return fptr_(static_cast<Args&&>(args)...); } - }; - - struct make_overload_t { - template <typename ...F, - typename Overload = typename overload_t< - typename detail::decay<F>::type... - >::type - > - constexpr Overload operator()(F&& ...f) const { - return Overload(static_cast<F&&>(f)...); - } - }; - - constexpr make_overload_t overload{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/overload_linearly.hpp b/contrib/restricted/boost/boost/hana/functional/overload_linearly.hpp deleted file mode 100644 index e4129d1169..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/overload_linearly.hpp +++ /dev/null @@ -1,110 +0,0 @@ -/*! -@file -Defines `boost::hana::overload_linearly`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP -#define BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Call the first function that produces a valid call expression. - //! - //! Given functions `f1, ..., fn`, `overload_linearly(f1, ..., fn)` is - //! a new function that calls the first `fk` producing a valid call - //! expression with the given arguments. Specifically, - //! @code - //! overload_linearly(f1, ..., fn)(args...) == fk(args...) - //! @endcode - //! - //! where `fk` is the _first_ function such that `fk(args...)` is a valid - //! expression. - //! - //! - //! Example - //! ------- - //! @include example/functional/overload_linearly.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto overload_linearly = [](auto&& f1, auto&& f2, ..., auto&& fn) { - return [perfect-capture](auto&& ...x) -> decltype(auto) { - return forwarded(fk)(forwarded(x)...); - }; - }; -#else - template <typename F, typename G> - struct overload_linearly_t { - F f; - G g; - - private: - template <typename ...Args, typename = - decltype(std::declval<F const&>()(std::declval<Args>()...))> - constexpr F const& which(int) const& { return f; } - - template <typename ...Args, typename = - decltype(std::declval<F&>()(std::declval<Args>()...))> - constexpr F& which(int) & { return f; } - - template <typename ...Args, typename = - decltype(std::declval<F&&>()(std::declval<Args>()...))> - constexpr F which(int) && { return static_cast<F&&>(f); } - - template <typename ...Args> - constexpr G const& which(long) const& { return g; } - - template <typename ...Args> - constexpr G& which(long) & { return g; } - - template <typename ...Args> - constexpr G which(long) && { return static_cast<G&&>(g); } - - public: - template <typename ...Args> - constexpr decltype(auto) operator()(Args&& ...args) const& - { return which<Args...>(int{})(static_cast<Args&&>(args)...); } - - template <typename ...Args> - constexpr decltype(auto) operator()(Args&& ...args) & - { return which<Args...>(int{})(static_cast<Args&&>(args)...); } - - template <typename ...Args> - constexpr decltype(auto) operator()(Args&& ...args) && - { return which<Args...>(int{})(static_cast<Args&&>(args)...); } - }; - - struct make_overload_linearly_t { - template <typename F, typename G> - constexpr overload_linearly_t< - typename detail::decay<F>::type, - typename detail::decay<G>::type - > operator()(F&& f, G&& g) const { - return {static_cast<F&&>(f), static_cast<G&&>(g)}; - } - - template <typename F, typename G, typename ...H> - constexpr decltype(auto) operator()(F&& f, G&& g, H&& ...h) const { - return (*this)(static_cast<F&&>(f), - (*this)(static_cast<G&&>(g), static_cast<H&&>(h)...)); - } - - template <typename F> - constexpr typename detail::decay<F>::type operator()(F&& f) const { - return static_cast<F&&>(f); - } - }; - - constexpr make_overload_linearly_t overload_linearly{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_OVERLOAD_LINEARLY_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/partial.hpp b/contrib/restricted/boost/boost/hana/functional/partial.hpp deleted file mode 100644 index cfe981dddf..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/partial.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Defines `boost::hana::partial`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_PARTIAL_HPP -#define BOOST_HANA_FUNCTIONAL_PARTIAL_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Partially apply a function to some arguments. - //! - //! Given a function `f` and some arguments, `partial` returns a new - //! function corresponding to the partially applied function `f`. This - //! allows providing some arguments to a function and letting the rest - //! of the arguments be provided later. Specifically, `partial(f, x...)` - //! is a function such that - //! @code - //! partial(f, x...)(y...) == f(x..., y...) - //! @endcode - //! - //! @note - //! The arity of `f` must match the total number of arguments passed to - //! it, i.e. `sizeof...(x) + sizeof...(y)`. - //! - //! - //! Example - //! ------- - //! @include example/functional/partial.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto partial = [](auto&& f, auto&& ...x) { - return [perfect-capture](auto&& ...y) -> decltype(auto) { - return forwarded(f)(forwarded(x)..., forwarded(y)...); - }; - }; -#else - template <typename Indices, typename F, typename ...X> - struct partial_t; - - struct make_partial_t { - struct secret { }; - template <typename F, typename ...X> - constexpr partial_t< - std::make_index_sequence<sizeof...(X)>, - typename detail::decay<F>::type, - typename detail::decay<X>::type... - > - operator()(F&& f, X&& ...x) const { - return {secret{}, static_cast<F&&>(f), static_cast<X&&>(x)...}; - } - }; - - template <std::size_t ...n, typename F, typename ...X> - struct partial_t<std::index_sequence<n...>, F, X...> { - partial_t() = default; - - template <typename ...T> - constexpr partial_t(make_partial_t::secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, X...> storage_; - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) const& { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)..., - static_cast<Y&&>(y)... - ); - } - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) & { - return hana::at_c<0>(storage_)( - hana::at_c<n+1>(storage_)..., - static_cast<Y&&>(y)... - ); - } - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) && { - return static_cast<F&&>(hana::at_c<0>(storage_))( - static_cast<X&&>(hana::at_c<n+1>(storage_))..., - static_cast<Y&&>(y)... - ); - } - }; - - constexpr make_partial_t partial{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_PARTIAL_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/placeholder.hpp b/contrib/restricted/boost/boost/hana/functional/placeholder.hpp deleted file mode 100644 index 59dea42bfb..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/placeholder.hpp +++ /dev/null @@ -1,263 +0,0 @@ -/*! -@file -Defines `boost::hana::_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP -#define BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/create.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Create simple functions representing C++ operators inline. - //! - //! Specifically, `_` is an object used as a placeholder to build - //! function objects representing calls to C++ operators. It works - //! by overloading the operators between `_` and any object so that - //! they return a function object which actually calls the corresponding - //! operator on its argument(s). Hence, for any supported operator `@`: - //! @code - //! (_ @ _)(x, y) == x @ y - //! @endcode - //! - //! Operators may also be partially applied to one argument inline: - //! @code - //! (x @ _)(y) == x @ y - //! (_ @ y)(x) == x @ y - //! @endcode - //! - //! When invoked with more arguments than required, functions created with - //! `_` will discard the superfluous instead of triggering an error: - //! @code - //! (_ @ _)(x, y, z...) == x @ y - //! @endcode - //! - //! This makes functions created with `_` easier to use in higher-order - //! algorithms, which sometime provide more information than necessary - //! to their callbacks. - //! - //! ### Supported operators - //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`, unary `-` - //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>` - //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=` - //! - %Logical: `||`, `&&`, `!` - //! - Member access: `*` (dereference), `[]` (array subscript) - //! - Other: `()` (function call) - //! - //! More complex functionality like the ability to compose placeholders - //! into larger function objects inline are not supported. This is on - //! purpose; you should either use C++14 generic lambdas or a library - //! like [Boost.Phoenix][] if you need bigger guns. The goal here is - //! to save you a couple of characters in simple situations. - //! - //! ### Example - //! @include example/functional/placeholder.cpp - //! - //! [Boost.Phoenix]: http://www.boost.org/doc/libs/release/libs/phoenix/doc/html/index.html -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr unspecified _{}; -#else - namespace placeholder_detail { - template <typename I> - struct subscript { - I i; - - template <typename Xs, typename ...Z> - constexpr auto operator()(Xs&& xs, Z const& ...) const& - -> decltype(static_cast<Xs&&>(xs)[i]) - { return static_cast<Xs&&>(xs)[i]; } - - template <typename Xs, typename ...Z> - constexpr auto operator()(Xs&& xs, Z const& ...) & - -> decltype(static_cast<Xs&&>(xs)[i]) - { return static_cast<Xs&&>(xs)[i]; } - - template <typename Xs, typename ...Z> - constexpr auto operator()(Xs&& xs, Z const& ...) && - -> decltype(static_cast<Xs&&>(xs)[std::declval<I>()]) - { return static_cast<Xs&&>(xs)[std::move(i)]; } - }; - - template <typename F, typename Xs, std::size_t ...i> - constexpr decltype(auto) invoke_impl(F&& f, Xs&& xs, std::index_sequence<i...>) { - return static_cast<F&&>(f)(hana::at_c<i>(static_cast<Xs&&>(xs).storage_)...); - } - - template <typename ...X> - struct invoke; - - struct placeholder { - struct secret { }; - - template <typename X> - constexpr decltype(auto) operator[](X&& x) const - { return detail::create<subscript>{}(static_cast<X&&>(x)); } - - template <typename ...X> - constexpr invoke<typename detail::decay<X>::type...> - operator()(X&& ...x) const { - return {secret{}, static_cast<X&&>(x)...}; - } - }; - - template <typename ...X> - struct invoke { - template <typename ...Y> - constexpr invoke(placeholder::secret, Y&& ...y) - : storage_{static_cast<Y&&>(y)...} - { } - - basic_tuple<X...> storage_; - - template <typename F, typename ...Z> - constexpr auto operator()(F&& f, Z const& ...) const& -> decltype( - static_cast<F&&>(f)(std::declval<X const&>()...) - ) { - return invoke_impl(static_cast<F&&>(f), *this, - std::make_index_sequence<sizeof...(X)>{}); - } - - template <typename F, typename ...Z> - constexpr auto operator()(F&& f, Z const& ...) & -> decltype( - static_cast<F&&>(f)(std::declval<X&>()...) - ) { - return invoke_impl(static_cast<F&&>(f), *this, - std::make_index_sequence<sizeof...(X)>{}); - } - - template <typename F, typename ...Z> - constexpr auto operator()(F&& f, Z const& ...) && -> decltype( - static_cast<F&&>(f)(std::declval<X&&>()...) - ) { - return invoke_impl(static_cast<F&&>(f), static_cast<invoke&&>(*this), - std::make_index_sequence<sizeof...(X)>{}); - } - }; - -#define BOOST_HANA_PLACEHOLDER_BINARY_OP(op, op_name) \ - template <typename X> \ - struct op_name ## _left { \ - X x; \ - \ - template <typename Y, typename ...Z> \ - constexpr auto operator()(Y&& y, Z const& ...) const& -> decltype( \ - std::declval<X const&>() op static_cast<Y&&>(y)) \ - { return x op static_cast<Y&&>(y); } \ - \ - template <typename Y, typename ...Z> \ - constexpr auto operator()(Y&& y, Z const& ...) & -> decltype( \ - std::declval<X&>() op static_cast<Y&&>(y)) \ - { return x op static_cast<Y&&>(y); } \ - \ - template <typename Y, typename ...Z> \ - constexpr auto operator()(Y&& y, Z const& ...) && -> decltype( \ - std::declval<X>() op static_cast<Y&&>(y)) \ - { return std::move(x) op static_cast<Y&&>(y); } \ - }; \ - \ - template <typename Y> \ - struct op_name ## _right { \ - Y y; \ - \ - template <typename X, typename ...Z> \ - constexpr auto operator()(X&& x, Z const& ...) const& -> decltype( \ - static_cast<X&&>(x) op std::declval<Y const&>()) \ - { return static_cast<X&&>(x) op y; } \ - \ - template <typename X, typename ...Z> \ - constexpr auto operator()(X&& x, Z const& ...) & -> decltype( \ - static_cast<X&&>(x) op std::declval<Y&>()) \ - { return static_cast<X&&>(x) op y; } \ - \ - template <typename X, typename ...Z> \ - constexpr auto operator()(X&& x, Z const& ...) && -> decltype( \ - static_cast<X&&>(x) op std::declval<Y>()) \ - { return static_cast<X&&>(x) op std::move(y); } \ - }; \ - \ - struct op_name { \ - template <typename X, typename Y, typename ...Z> \ - constexpr auto operator()(X&& x, Y&& y, Z const& ...) const -> decltype(\ - static_cast<X&&>(x) op static_cast<Y&&>(y)) \ - { return static_cast<X&&>(x) op static_cast<Y&&>(y); } \ - }; \ - \ - template <typename X> \ - constexpr decltype(auto) operator op (X&& x, placeholder) \ - { return detail::create<op_name ## _left>{}(static_cast<X&&>(x)); } \ - \ - template <typename Y> \ - constexpr decltype(auto) operator op (placeholder, Y&& y) \ - { return detail::create<op_name ## _right>{}(static_cast<Y&&>(y)); } \ - \ - inline constexpr decltype(auto) operator op (placeholder, placeholder) \ - { return op_name{}; } \ -/**/ - -#define BOOST_HANA_PLACEHOLDER_UNARY_OP(op, op_name) \ - struct op_name { \ - template <typename X, typename ...Z> \ - constexpr auto operator()(X&& x, Z const& ...) const \ - -> decltype(op static_cast<X&&>(x)) \ - { return op static_cast<X&&>(x); } \ - }; \ - \ - inline constexpr decltype(auto) operator op (placeholder) \ - { return op_name{}; } \ -/**/ - // Arithmetic - BOOST_HANA_PLACEHOLDER_UNARY_OP(+, unary_plus) - BOOST_HANA_PLACEHOLDER_UNARY_OP(-, unary_minus) - BOOST_HANA_PLACEHOLDER_BINARY_OP(+, plus) - BOOST_HANA_PLACEHOLDER_BINARY_OP(-, minus) - BOOST_HANA_PLACEHOLDER_BINARY_OP(*, times) - BOOST_HANA_PLACEHOLDER_BINARY_OP(/, divide) - BOOST_HANA_PLACEHOLDER_BINARY_OP(%, modulo) - - // Bitwise - BOOST_HANA_PLACEHOLDER_UNARY_OP(~, bitwise_not) - BOOST_HANA_PLACEHOLDER_BINARY_OP(&, bitwise_and) - BOOST_HANA_PLACEHOLDER_BINARY_OP(|, bitwise_or) - BOOST_HANA_PLACEHOLDER_BINARY_OP(^, bitwise_xor) - BOOST_HANA_PLACEHOLDER_BINARY_OP(<<, left_shift) - BOOST_HANA_PLACEHOLDER_BINARY_OP(>>, right_shift) - - // Comparison - BOOST_HANA_PLACEHOLDER_BINARY_OP(==, equal) - BOOST_HANA_PLACEHOLDER_BINARY_OP(!=, not_equal) - BOOST_HANA_PLACEHOLDER_BINARY_OP(<, less) - BOOST_HANA_PLACEHOLDER_BINARY_OP(<=, less_equal) - BOOST_HANA_PLACEHOLDER_BINARY_OP(>, greater) - BOOST_HANA_PLACEHOLDER_BINARY_OP(>=, greater_equal) - - // Logical - BOOST_HANA_PLACEHOLDER_BINARY_OP(||, logical_or) - BOOST_HANA_PLACEHOLDER_BINARY_OP(&&, logical_and) - BOOST_HANA_PLACEHOLDER_UNARY_OP(!, logical_not) - - // Member access (array subscript is a member function) - BOOST_HANA_PLACEHOLDER_UNARY_OP(*, dereference) - - // Other (function call is a member function) - -#undef BOOST_HANA_PREFIX_PLACEHOLDER_OP -#undef BOOST_HANA_BINARY_PLACEHOLDER_OP - } // end namespace placeholder_detail - - constexpr placeholder_detail::placeholder _{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_PLACEHOLDER_HPP diff --git a/contrib/restricted/boost/boost/hana/functional/reverse_partial.hpp b/contrib/restricted/boost/boost/hana/functional/reverse_partial.hpp deleted file mode 100644 index 60fc59e400..0000000000 --- a/contrib/restricted/boost/boost/hana/functional/reverse_partial.hpp +++ /dev/null @@ -1,103 +0,0 @@ -/*! -@file -Defines `boost::hana::reverse_partial`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP -#define BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-functional - //! Partially apply a function to some arguments. - //! - //! Given a function `f` and some arguments, `reverse_partial` returns a - //! new function corresponding to `f` whose last arguments are partially - //! applied. Specifically, `reverse_partial(f, x...)` is a function such - //! that - //! @code - //! reverse_partial(f, x...)(y...) == f(y..., x...) - //! @endcode - //! - //! @note - //! The arity of `f` must match the total number of arguments passed to - //! it, i.e. `sizeof...(x) + sizeof...(y)`. - //! - //! - //! Example - //! ------- - //! @include example/functional/reverse_partial.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto reverse_partial = [](auto&& f, auto&& ...x) { - return [perfect-capture](auto&& ...y) -> decltype(auto) { - return forwarded(f)(forwarded(y)..., forwarded(x)...); - }; - }; -#else - template <typename Indices, typename F, typename ...X> - struct reverse_partial_t; - - struct make_reverse_partial_t { - struct secret { }; - template <typename F, typename ...X> - constexpr reverse_partial_t< - std::make_index_sequence<sizeof...(X)>, - typename detail::decay<F>::type, - typename detail::decay<X>::type... - > operator()(F&& f, X&& ...x) const { - return {secret{}, static_cast<F&&>(f), static_cast<X&&>(x)...}; - } - }; - - template <std::size_t ...n, typename F, typename ...X> - struct reverse_partial_t<std::index_sequence<n...>, F, X...> { - reverse_partial_t() = default; - - template <typename ...T> - constexpr reverse_partial_t(make_reverse_partial_t::secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, X...> storage_; - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) const& { - return hana::at_c<0>(storage_)( - static_cast<Y&&>(y)..., - hana::at_c<n+1>(storage_)... - ); - } - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) & { - return hana::at_c<0>(storage_)( - static_cast<Y&&>(y)..., - hana::at_c<n+1>(storage_)... - ); - } - - template <typename ...Y> - constexpr decltype(auto) operator()(Y&& ...y) && { - return static_cast<F&&>(hana::at_c<0>(storage_))( - static_cast<Y&&>(y)..., - static_cast<X&&>(hana::at_c<n+1>(storage_))... - ); - } - }; - - constexpr make_reverse_partial_t reverse_partial{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUNCTIONAL_REVERSE_PARTIAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fuse.hpp b/contrib/restricted/boost/boost/hana/fuse.hpp deleted file mode 100644 index 960aaee1bc..0000000000 --- a/contrib/restricted/boost/boost/hana/fuse.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Defines `boost::hana::fuse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FUSE_HPP -#define BOOST_HANA_FUSE_HPP - -#include <boost/hana/fwd/fuse.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename F> - struct fused { - F f; - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const& - { return hana::unpack(static_cast<Xs&&>(xs), f); } - - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) & - { return hana::unpack(static_cast<Xs&&>(xs), f); } - - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) && - { return hana::unpack(static_cast<Xs&&>(xs), static_cast<F&&>(f)); } - }; - } - - //! @cond - template <typename F> - constexpr auto fuse_t::operator()(F&& f) const { - return detail::fused<typename detail::decay<F>::type>{static_cast<F&&>(f)}; - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FUSE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/accessors.hpp b/contrib/restricted/boost/boost/hana/fwd/accessors.hpp deleted file mode 100644 index ca337d1965..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/accessors.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Forward declares `boost::hana::accessors`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ACCESSORS_HPP -#define BOOST_HANA_FWD_ACCESSORS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Sequence` of pairs representing the accessors of the - //! data structure. - //! @ingroup group-Struct - //! - //! Given a `Struct` `S`, `accessors<S>()` is a `Sequence` of `Product`s - //! where the first element of each pair is the "name" of a member of - //! the `Struct`, and the second element of each pair is a function that - //! can be used to access that member when given an object of the proper - //! data type. As described in the global documentation for `Struct`, the - //! accessor functions in this sequence must be move-independent. - //! - //! - //! Example - //! ------- - //! @include example/accessors.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename S> - constexpr auto accessors = []() { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct accessors_impl : accessors_impl<S, when<true>> { }; - - template <typename S> - struct accessors_t; - - template <typename S> - constexpr accessors_t<S> accessors{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ACCESSORS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/adapt_adt.hpp b/contrib/restricted/boost/boost/hana/fwd/adapt_adt.hpp deleted file mode 100644 index a7658ca628..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/adapt_adt.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Documents the `BOOST_HANA_ADAPT_ADT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ADAPT_ADT_HPP -#define BOOST_HANA_FWD_ADAPT_ADT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: - // The weird definition as a variable seems to exploit a glitch in Doxygen - // which makes the macro appear in the related objects of Struct (as we - // want it to). - - //! Defines a model of `Struct` with the given accessors. - //! @ingroup group-Struct - //! - //! Using this macro at _global scope_ will define a model of the `Struct` - //! concept for the given type. This can be used to easily adapt existing - //! user-defined types in a ad-hoc manner. Unlike `BOOST_HANA_ADAPT_STRUCT`, - //! this macro requires specifying the way to retrieve each member by - //! providing a function that does the extraction. - //! - //! @note - //! This macro only works if the tag of the user-defined type `T` is `T` - //! itself. This is the case unless you specifically asked for something - //! different; see `tag_of`'s documentation. - //! - //! - //! Example - //! ------- - //! @include example/adapt_adt.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto BOOST_HANA_ADAPT_ADT(...) = ; - #define BOOST_HANA_ADAPT_ADT(Name, ...) see documentation -#else - // defined in <boost/hana/adapt_adt.hpp> -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ADAPT_ADT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/adapt_struct.hpp b/contrib/restricted/boost/boost/hana/fwd/adapt_struct.hpp deleted file mode 100644 index b03da6463b..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/adapt_struct.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Documents the `BOOST_HANA_ADAPT_STRUCT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ADAPT_STRUCT_HPP -#define BOOST_HANA_FWD_ADAPT_STRUCT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: - // The weird definition as a variable seems to exploit a glitch in Doxygen - // which makes the macro appear in the related objects of Struct (as we - // want it to). - - //! Defines a model of `Struct` with the given members. - //! @ingroup group-Struct - //! - //! Using this macro at _global scope_ will define a model of the `Struct` - //! concept for the given type. This can be used to easily adapt existing - //! user-defined types in a ad-hoc manner. Unlike the - //! `BOOST_HANA_DEFINE_STRUCT` macro, this macro does not - //! require the types of the members to be specified. - //! - //! @note - //! This macro only works if the tag of the user-defined type `T` is `T` - //! itself. This is the case unless you specifically asked for something - //! different; see `tag_of`'s documentation. - //! - //! - //! Example - //! ------- - //! @include example/adapt_struct.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto BOOST_HANA_ADAPT_STRUCT(...) = ; - #define BOOST_HANA_ADAPT_STRUCT(Name, ...) see documentation -#else - // defined in <boost/hana/adapt_struct.hpp> -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ADAPT_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/adjust.hpp b/contrib/restricted/boost/boost/hana/fwd/adjust.hpp deleted file mode 100644 index 8fec6f0b3d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/adjust.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/*! -@file -Forward declares `boost::hana::adjust`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ADJUST_HPP -#define BOOST_HANA_FWD_ADJUST_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Apply a function on all the elements of a structure that compare - //! equal to some value. - //! @ingroup group-Functor - //! - //! - //! Signature - //! --------- - //! Given `F` a Functor and `U` a type that can be compared with `T`'s, - //! the signature is - //! \f$ - //! \mathtt{adjust} : F(T) \times U \times (T \to T) \to F(T) - //! \f$ - //! - //! @param xs - //! The structure to adjust with `f`. - //! - //! @param value - //! An object that is compared with each element `x` of the structure. - //! Elements of the structure that compare equal to `value` are adjusted - //! with the `f` function. - //! - //! @param f - //! A function called as `f(x)` on the element(s) of the structure that - //! compare equal to `value`. - //! - //! - //! Example - //! ------- - //! @include example/adjust.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto adjust = [](auto&& xs, auto&& value, auto&& f) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct adjust_impl : adjust_impl<Xs, when<true>> { }; - - struct adjust_t { - template <typename Xs, typename Value, typename F> - constexpr auto operator()(Xs&& xs, Value&& value, F&& f) const; - }; - - constexpr adjust_t adjust{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ADJUST_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/adjust_if.hpp b/contrib/restricted/boost/boost/hana/fwd/adjust_if.hpp deleted file mode 100644 index 3042dc72c9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/adjust_if.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/*! -@file -Forward declares `boost::hana::adjust_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ADJUST_IF_HPP -#define BOOST_HANA_FWD_ADJUST_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Apply a function on all the elements of a structure satisfying a predicate. - //! @ingroup group-Functor - //! - //! Given a Functor, a predicate `pred` and a function `f`, `adjust_if` - //! will _adjust_ the elements of the Functor that satisfy the predicate - //! with the function `f`. In other words, `adjust_if` will return a new - //! Functor equal to the original one, except that the elements satisfying - //! the predicate will be transformed with the given function. Elements - //! for which the predicate is not satisfied are left untouched, and they - //! are kept as-is in the resulting Functor. - //! - //! - //! Signature - //! --------- - //! Given a `Functor` `F` and a `Logical` `Bool`, the signature is - //! \f$ - //! \mathtt{adjust\_if} : F(T) \times (T \to Bool) \times (T \to T) \to F(T) - //! \f$ - //! - //! @param xs - //! The structure to adjust with `f`. - //! - //! @param pred - //! A function called as `pred(x)` for each element of the Functor, - //! and returning whether `f` should be applied on that element. - //! - //! @param f - //! A function called as `f(x)` on the element(s) of the Functor that - //! satisfy the predicate. - //! - //! - //! Example - //! ------- - //! @include example/adjust_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto adjust_if = [](auto&& xs, auto const& pred, auto const& f) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct adjust_if_impl : adjust_if_impl<Xs, when<true>> { }; - - struct adjust_if_t { - template <typename Xs, typename Pred, typename F> - constexpr auto operator()(Xs&& xs, Pred const& pred, F const& f) const; - }; - - constexpr adjust_if_t adjust_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ADJUST_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/all.hpp b/contrib/restricted/boost/boost/hana/fwd/all.hpp deleted file mode 100644 index eca239ebef..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/all.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Forward declares `boost::hana::all`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ALL_HPP -#define BOOST_HANA_FWD_ALL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether all the keys of the structure are true-valued. - //! @ingroup group-Searchable - //! - //! The keys of the structure must be `Logical`s. If the structure is not - //! finite, a false-valued key must appear at a finite "index" in order - //! for this method to finish. - //! - //! - //! Example - //! ------- - //! @include example/all.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto all = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct all_impl : all_impl<S, when<true>> { }; - - struct all_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr all_t all{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ALL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/all_of.hpp b/contrib/restricted/boost/boost/hana/fwd/all_of.hpp deleted file mode 100644 index 3aabf29063..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/all_of.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Forward declares `boost::hana::all_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ALL_OF_HPP -#define BOOST_HANA_FWD_ALL_OF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether all the keys of the structure satisfy the `predicate`. - //! @ingroup group-Searchable - //! - //! If the structure is not finite, `predicate` has to return a false- - //! valued `Logical` after looking at a finite number of keys for this - //! method to finish. - //! - //! - //! @param xs - //! The structure to search. - //! - //! @param predicate - //! A function called as `predicate(k)`, where `k` is a key of the - //! structure, and returning a `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/all_of.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto all_of = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct all_of_impl : all_of_impl<S, when<true>> { }; - - struct all_of_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr all_of_t all_of{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ALL_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/and.hpp b/contrib/restricted/boost/boost/hana/fwd/and.hpp deleted file mode 100644 index 026cacabaf..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/and.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Forward declares `boost::hana::and_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_AND_HPP -#define BOOST_HANA_FWD_AND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return whether all the arguments are true-valued. - //! @ingroup group-Logical - //! - //! `and_` can be called with one argument or more. When called with - //! two arguments, `and_` uses tag-dispatching to find the right - //! implementation. Otherwise, - //! @code - //! and_(x) == x - //! and_(x, y, ...z) == and_(and_(x, y), z...) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/and.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto and_ = [](auto&& x, auto&& ...y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct and_impl : and_impl<L, when<true>> { }; - - struct and_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - - template <typename X, typename ...Y> - constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; - }; - - constexpr and_t and_{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_AND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/any.hpp b/contrib/restricted/boost/boost/hana/fwd/any.hpp deleted file mode 100644 index 6281236ad6..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/any.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Forward declares `boost::hana::any`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ANY_HPP -#define BOOST_HANA_FWD_ANY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether any key of the structure is true-valued. - //! @ingroup group-Searchable - //! - //! The keys of the structure must be `Logical`s. If the structure is not - //! finite, a true-valued key must appear at a finite "index" in order for - //! this method to finish. - //! - //! - //! Example - //! ------- - //! @include example/any.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto any = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct any_impl : any_impl<S, when<true>> { }; - - struct any_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr any_t any{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ANY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/any_of.hpp b/contrib/restricted/boost/boost/hana/fwd/any_of.hpp deleted file mode 100644 index a9408bd1b5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/any_of.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Forward declares `boost::hana::any_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ANY_OF_HPP -#define BOOST_HANA_FWD_ANY_OF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether any key of the structure satisfies the `predicate`. - //! @ingroup group-Searchable - //! - //! If the structure is not finite, `predicate` has to be satisfied - //! after looking at a finite number of keys for this method to finish. - //! - //! - //! @param xs - //! The structure to search. - //! - //! @param predicate - //! A function called as `predicate(k)`, where `k` is a key of the - //! structure, and returning a `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/any_of.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto any_of = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct any_of_impl : any_of_impl<S, when<true>> { }; - - struct any_of_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr any_of_t any_of{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ANY_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/ap.hpp b/contrib/restricted/boost/boost/hana/fwd/ap.hpp deleted file mode 100644 index 6f7b147090..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/ap.hpp +++ /dev/null @@ -1,82 +0,0 @@ -/*! -@file -Forward declares `boost::hana::ap`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_AP_HPP -#define BOOST_HANA_FWD_AP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Lifted application. - //! @ingroup group-Applicative - //! - //! Specifically, `ap` applies a structure containing functions to a - //! structure containing values, and returns a new structure containing - //! values. The exact way in which the functions are applied to the values - //! depends on the `Applicative`. - //! - //! `ap` can be called with two arguments or more; the functions in the `f` - //! structure are curried and then applied to the values in each `x...` - //! structure using the binary form of `ap`. Note that this requires the - //! number of `x...` must match the arity of the functions in the `f` - //! structure. In other words, `ap(f, x1, ..., xN)` is equivalent to - //! @code - //! ((f' <ap> x1) <ap> x2) ... <ap> xN - //! @endcode - //! where `f'` is `f` but containing curried functions instead and - //! `x <ap> y` is just `ap(x, y)` written in infix notation to emphasize - //! the left associativity. - //! - //! - //! Signature - //! --------- - //! Given an Applicative `A`, the signature is - //! @f$ \mathtt{ap} : A(T_1 \times \cdots \times T_n \to U) - //! \times A(T_1) \times \cdots \times A(T_n) - //! \to A(U) @f$. - //! - //! @param f - //! A structure containing function(s). - //! - //! @param x... - //! Structure(s) containing value(s) and on which `f` is applied. The - //! number of structures must match the arity of the functions in the - //! `f` structure. - //! - //! - //! Example - //! ------- - //! @include example/ap.cpp - //! - //! @todo - //! Consider giving access to all the arguments to the tag-dispatched - //! implementation for performance purposes. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto ap = [](auto&& f, auto&& ...x) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename A, typename = void> - struct ap_impl : ap_impl<A, when<true>> { }; - - struct ap_t { - template <typename F, typename X> - constexpr decltype(auto) operator()(F&& f, X&& x) const; - - template <typename F, typename ...Xs> - constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const; - }; - - constexpr ap_t ap{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_AP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/append.hpp b/contrib/restricted/boost/boost/hana/fwd/append.hpp deleted file mode 100644 index 94b2105c93..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/append.hpp +++ /dev/null @@ -1,68 +0,0 @@ -/*! -@file -Forward declares `boost::hana::append`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_APPEND_HPP -#define BOOST_HANA_FWD_APPEND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Append an element to a monadic structure. - //! @ingroup group-MonadPlus - //! - //! Given an element `x` and a monadic structure `xs`, `append` returns a - //! new monadic structure which is the result of lifting `x` into the - //! monadic structure and then combining that (to the right) with `xs`. - //! In other words, - //! @code - //! append(xs, x) == concat(xs, lift<Xs>(x)) - //! @endcode - //! where `Xs` is the tag of `xs`. For sequences, this has the intuitive - //! behavior of simply appending an element to the end of the sequence, - //! hence the name. - //! - //! > #### Rationale for not calling this `push_back` - //! > See the rationale for using `prepend` instead of `push_front`. - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M`, the signature is - //! @f$ \mathtt{append} : M(T) \times T \to M(T) @f$. - //! - //! @param xs - //! A monadic structure that will be combined to the left of the element. - //! - //! @param x - //! An element to combine to the right of the monadic structure. - //! - //! - //! Example - //! ------- - //! @include example/append.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto append = [](auto&& xs, auto&& x) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct append_impl : append_impl<M, when<true>> { }; - - struct append_t { - template <typename Xs, typename X> - constexpr auto operator()(Xs&& xs, X&& x) const; - }; - - constexpr append_t append{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_APPEND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/at.hpp b/contrib/restricted/boost/boost/hana/fwd/at.hpp deleted file mode 100644 index ea03114ed7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/at.hpp +++ /dev/null @@ -1,89 +0,0 @@ -/*! -@file -Forward declares `boost::hana::at` and `boost::hana::at_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_AT_HPP -#define BOOST_HANA_FWD_AT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the `n`th element of an iterable. - //! @ingroup group-Iterable - //! - //! Given an `Iterable` and an `IntegralConstant` index, `at` returns the - //! element located at the index in the linearization of the iterable. - //! Specifically, given an iterable `xs` with a linearization of - //! `[x1, ..., xN]`, `at(xs, k)` is equivalent to `xk`. - //! - //! If the `Iterable` actually stores the elements it contains, `at` is - //! required to return a lvalue reference, a lvalue reference to const - //! or a rvalue reference to the matching element, where the type of - //! reference must match that of the iterable passed to `at`. If the - //! `Iterable` does not store the elements it contains (i.e. it generates - //! them on demand), this requirement is dropped. - //! - //! - //! @param xs - //! The iterable in which an element is retrieved. The iterable must - //! contain at least `n + 1` elements. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the 0-based index of - //! the element to return. It is an error to call `at` with an index that - //! out of bounds of the iterable. - //! - //! - //! Example - //! ------- - //! @include example/at.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto at = [](auto&& xs, auto const& n) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct at_impl : at_impl<It, when<true>> { }; - - struct at_t { - template <typename Xs, typename N> - constexpr decltype(auto) operator()(Xs&& xs, N const& n) const; - }; - - constexpr at_t at{}; -#endif - - //! Equivalent to `at`; provided for convenience. - //! @ingroup group-Iterable - //! - //! - //! @note - //! `hana::at_c<n>` is an overloaded function, not a function object. - //! Hence, it can't be passed to higher-order algorithms. This is done - //! for compile-time performance reasons. - //! - //! - //! Example - //! ------- - //! @include example/at_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto at_c = [](auto&& xs) { - return hana::at(forwarded(xs), hana::size_c<n>); - }; -#else - template <std::size_t n, typename Xs> - constexpr decltype(auto) at_c(Xs&& xs); -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/at_key.hpp b/contrib/restricted/boost/boost/hana/fwd/at_key.hpp deleted file mode 100644 index 29134565a5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/at_key.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*! -@file -Forward declares `boost::hana::at_key`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_AT_KEY_HPP -#define BOOST_HANA_FWD_AT_KEY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the value associated to the given key in a structure, or fail. - //! @ingroup group-Searchable - //! - //! Given a `key` and a `Searchable` structure, `at_key` returns the first - //! value whose key is equal to the given `key`, and fails at compile-time - //! if no such key exists. This requires the `key` to be compile-time - //! `Comparable`, exactly like for `find`. `at_key` satisfies the following: - //! @code - //! at_key(xs, key) == find(xs, key).value() - //! @endcode - //! - //! If the `Searchable` actually stores the elements it contains, `at_key` - //! is required to return a lvalue reference, a lvalue reference to const - //! or a rvalue reference to the found value, where the type of reference - //! must match that of the structure passed to `at_key`. If the `Searchable` - //! does not store the elements it contains (i.e. it generates them on - //! demand), this requirement is dropped. - //! - //! - //! @param xs - //! The structure to be searched. - //! - //! @param key - //! A key to be searched for in the structure. The key has to be - //! `Comparable` with the other keys of the structure. In the current - //! version of the library, the comparison of `key` with any other key - //! of the structure must return a compile-time `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/at_key.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto at_key = [](auto&& xs, auto const& key) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct at_key_impl : at_key_impl<S, when<true>> { }; - - struct at_key_t { - template <typename Xs, typename Key> - constexpr decltype(auto) operator()(Xs&& xs, Key const& key) const; - }; - - constexpr at_key_t at_key{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_AT_KEY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/back.hpp b/contrib/restricted/boost/boost/hana/fwd/back.hpp deleted file mode 100644 index 8356cddeab..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/back.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Forward declares `boost::hana::back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_BACK_HPP -#define BOOST_HANA_FWD_BACK_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the last element of a non-empty and finite iterable. - //! @ingroup group-Iterable - //! - //! Given a non-empty and finite iterable `xs` with a linearization of - //! `[x1, ..., xN]`, `back(xs)` is equal to `xN`. Equivalently, `back(xs)` - //! must be equivalent to `at_c<N-1>(xs)`, and that regardless of the - //! value category of `xs` (`back` must respect the reference semantics - //! of `at`). - //! - //! - //! Example - //! ------- - //! @include example/back.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto back = [](auto&& xs) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct back_impl : back_impl<It, when<true>> { }; - - struct back_t { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const; - }; - - constexpr back_t back{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/basic_tuple.hpp b/contrib/restricted/boost/boost/hana/fwd/basic_tuple.hpp deleted file mode 100644 index 8444f0f50e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/basic_tuple.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Forward declares `boost::hana::basic_tuple`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_BASIC_TUPLE_HPP -#define BOOST_HANA_FWD_BASIC_TUPLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! Stripped down version of `hana::tuple`. - //! - //! Whereas `hana::tuple` aims to provide an interface somewhat close to a - //! `std::tuple`, `basic_tuple` provides the strict minimum required to - //! implement a closure with maximum compile-time efficiency. - //! - //! - //! Modeled concepts - //! ---------------- - //! `Sequence`, and all the concepts it refines - template <typename ...Xs> - struct basic_tuple; - - //! Tag representing `hana::basic_tuple`. - //! @relates hana::basic_tuple - struct basic_tuple_tag { }; - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Function object for creating a `basic_tuple`. - //! @relates hana::basic_tuple - //! - //! Given zero or more objects `xs...`, `make<basic_tuple_tag>` returns a - //! new `basic_tuple` containing those objects. The elements are held by - //! value inside the resulting tuple, and they are hence copied or moved - //! in. This is analogous to `std::make_tuple` for creating `basic_tuple`s. - //! - //! - //! Example - //! ------- - //! @include example/basic_tuple/make.cpp - template <> - constexpr auto make<basic_tuple_tag> = [](auto&& ...xs) { - return basic_tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; - }; -#endif - - //! Alias to `make<basic_tuple_tag>`; provided for convenience. - //! @relates hana::basic_tuple - //! - //! - //! Example - //! ------- - //! @include example/basic_tuple/make.cpp - constexpr auto make_basic_tuple = make<basic_tuple_tag>; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_BASIC_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/bool.hpp b/contrib/restricted/boost/boost/hana/fwd/bool.hpp deleted file mode 100644 index 123c992c62..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/bool.hpp +++ /dev/null @@ -1,15 +0,0 @@ -/*! -@file -Includes boost/hana/fwd/integral_constant.hpp. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_BOOL_HPP -#define BOOST_HANA_FWD_BOOL_HPP - -#include <boost/hana/fwd/integral_constant.hpp> - -#endif // !BOOST_HANA_FWD_BOOL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/cartesian_product.hpp b/contrib/restricted/boost/boost/hana/fwd/cartesian_product.hpp deleted file mode 100644 index a3a48f23f3..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/cartesian_product.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Forward declares `boost::hana::cartesian_product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP -#define BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Computes the cartesian product of a sequence of sequences. - //! @ingroup group-Sequence - //! - //! Given a sequence of sequences, `cartesian_product` returns a new - //! sequence of sequences containing the cartesian product of the - //! original sequences. For this method to finish, a finite number - //! of finite sequences must be provided. - //! - //! @note - //! All the sequences must have the same tag, and that tag must also match - //! that of the top-level sequence. - //! - //! - //! Signature - //! --------- - //! Given a `Sequence` `S(T)`, the signature is - //! \f[ - //! \mathtt{cartesian\_product} : S(S(T)) \to S(S(T)) - //! \f] - //! - //! @param xs - //! A sequence of sequences of which the cartesian product is computed. - //! - //! - //! Example - //! ------- - //! @include example/cartesian_product.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto cartesian_product = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct cartesian_product_impl : cartesian_product_impl<S, when<true>> { }; - - struct cartesian_product_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr cartesian_product_t cartesian_product{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/chain.hpp b/contrib/restricted/boost/boost/hana/fwd/chain.hpp deleted file mode 100644 index aa7f311057..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/chain.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*! -@file -Forward declares `boost::hana::chain`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CHAIN_HPP -#define BOOST_HANA_FWD_CHAIN_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Feed a monadic value into a monadic computation. - //! @ingroup group-Monad - //! - //! Given a monadic value and a monadic function, `chain` feeds the - //! monadic value into the function, thus performing some Monad-specific - //! effects, and returns the result. An implementation of `chain` must - //! satisfy - //! @code - //! chain(xs, f) == flatten(transform(xs, f)) - //! @endcode - //! - //! - //! Signature - //! --------- - //! For a monad `M`, given a monadic value of type `M(A)` and a monadic - //! function @f$ f : A \to M(B) @f$, `chain` has the signature - //! @f$ - //! \mathtt{chain} : M(A) \times (A \to M(B)) \to M(B) - //! @f$. - //! - //! @param xs - //! A monadic value to be fed to the function `f`. - //! - //! @param f - //! A function taking a normal value in the `xs` structure, and returning - //! a monadic value. This function is called as `f(x)`, where `x` is an - //! element of the structure `xs`. - //! - //! - //! Example - //! ------- - //! @include example/chain.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto chain = [](auto&& xs, auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct chain_impl : chain_impl<M, when<true>> { }; - - struct chain_t { - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; - }; - - constexpr chain_t chain{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CHAIN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/comparing.hpp b/contrib/restricted/boost/boost/hana/fwd/comparing.hpp deleted file mode 100644 index 376ab173c7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/comparing.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Forward declares `boost::hana::comparing`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_COMPARING_HPP -#define BOOST_HANA_FWD_COMPARING_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a function performing `equal` after applying a transformation - //! to both arguments. - //! @ingroup group-Comparable - //! - //! `comparing` creates an equivalence relation based on the result of - //! applying a function to some objects, which is especially useful in - //! conjunction with algorithms that accept a custom predicate that must - //! represent an equivalence relation. - //! - //! Specifically, `comparing` is such that - //! @code - //! comparing(f) == equal ^on^ f - //! @endcode - //! or, equivalently, - //! @code - //! comparing(f)(x, y) == equal(f(x), f(y)) - //! @endcode - //! - //! @note - //! This is not a tag-dispatched method (hence it can't be customized), - //! but just a convenience function provided with the `Comparable` concept. - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and a Comparable `B`, the signature is - //! @f$ \mathtt{comparing} : (A \to B) \to (A \times A \to Bool) @f$. - //! - //! - //! Example - //! ------- - //! @include example/comparing.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto comparing = [](auto&& f) { - return [perfect-capture](auto&& x, auto&& y) { - return equal(f(forwarded(x)), f(forwarded(y))); - }; - }; -#else - struct comparing_t { - template <typename F> - constexpr auto operator()(F&& f) const; - }; - - constexpr comparing_t comparing{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_COMPARING_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concat.hpp b/contrib/restricted/boost/boost/hana/fwd/concat.hpp deleted file mode 100644 index 140c847909..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concat.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::concat`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCAT_HPP -#define BOOST_HANA_FWD_CONCAT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Combine two monadic structures together. - //! @ingroup group-MonadPlus - //! - //! Given two monadic structures, `concat` combines them together and - //! returns a new monadic structure. The exact definition of `concat` - //! will depend on the exact model of MonadPlus at hand, but for - //! sequences it corresponds intuitively to simple concatenation. - //! - //! Also note that combination is not required to be commutative. - //! In other words, there is no requirement that - //! @code - //! concat(xs, ys) == concat(ys, xs) - //! @endcode - //! and indeed it does not hold in general. - //! - //! - //! Signature - //! --------- - //! Given a `MonadPlus` `M`, the signature of `concat` is - //! @f$ \mathtt{concat} : M(T) \times M(T) \to M(T) @f$. - //! - //! @param xs, ys - //! Two monadic structures to combine together. - //! - //! - //! Example - //! ------- - //! @include example/concat.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto concat = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct concat_impl : concat_impl<M, when<true>> { }; - - struct concat_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&& xs, Ys&& ys) const; - }; - - constexpr concat_t concat{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCAT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/applicative.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/applicative.hpp deleted file mode 100644 index 2c8677940c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/applicative.hpp +++ /dev/null @@ -1,117 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Applicative`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP -#define BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Applicative Applicative - //! The `Applicative` concept represents `Functor`s with the ability - //! to lift values and combine computations. - //! - //! A `Functor` can only take a normal function and map it over a - //! structure containing values to obtain a new structure containing - //! values. Intuitively, an `Applicative` can also take a value and - //! lift it into the structure. In addition, an `Applicative` can take - //! a structure containing functions and apply it to a structure - //! containing values to obtain a new structure containing values. - //! By currying the function(s) inside the structure, it is then - //! also possible to apply n-ary functions to n structures containing - //! values. - //! - //! @note - //! This documentation does not go into much details about the nature - //! of applicatives. However, the [Typeclassopedia][1] is a nice - //! Haskell-oriented resource where such information can be found. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `lift` and `ap` satisfying the laws below. An `Applicative` must - //! also be a `Functor`. - //! - //! - //! Laws - //! ---- - //! Given an `Applicative` `F`, the following laws must be satisfied: - //! 1. Identity\n - //! For all objects `xs` of tag `F(A)`, - //! @code - //! ap(lift<F>(id), xs) == xs - //! @endcode - //! - //! 2. Composition\n - //! For all objects `xs` of tag `F(A)` and functions-in-an-applicative - //! @f$ fs : F(B \to C) @f$, - //! @f$ gs : F(A \to B) @f$, - //! @code - //! ap(ap(lift<F>(compose), fs, gs), xs) == ap(fs, ap(gs, xs)) - //! @endcode - //! - //! 3. Homomorphism\n - //! For all objects `x` of tag `A` and functions @f$ f : A \to B @f$, - //! @code - //! ap(lift<F>(f), lift<F>(x)) == lift<F>(f(x)) - //! @endcode - //! - //! 4. Interchange\n - //! For all objects `x` of tag `A` and functions-in-an-applicative - //! @f$ fs : F(A \to B) @f$, - //! @code - //! ap(fs, lift<F>(x)) == ap(lift<F>(apply(-, x)), fs) - //! @endcode - //! where `apply(-, x)` denotes the partial application of the `apply` - //! function from the @ref group-functional module to the `x` argument. - //! - //! As a consequence of these laws, the model of `Functor` for `F` will - //! satisfy the following for all objects `xs` of tag `F(A)` and functions - //! @f$ f : A \to B @f$: - //! @code - //! transform(xs, f) == ap(lift<F>(f), xs) - //! @endcode - //! - //! - //! Refined concept - //! --------------- - //! 1. `Functor` (free model)\n - //! As a consequence of the laws, any `Applicative F` can be made a - //! `Functor` by setting - //! @code - //! transform(xs, f) = ap(lift<F>(f), xs) - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::lazy`, `hana::optional`, `hana::tuple` - //! - //! - //! @anchor applicative-transformation - //! Structure-preserving functions - //! ------------------------------ - //! An _applicative transformation_ is a function @f$ t : F(X) \to G(X) @f$ - //! between two Applicatives `F` and `G`, where `X` can be any tag, and - //! which preserves the operations of an Applicative. In other words, for - //! all objects `x` of tag `X`, functions-in-an-applicative - //! @f$ fs : F(X \to Y) @f$ and objects `xs` of tag `F(X)`, - //! @code - //! t(lift<F>(x)) == lift<G>(x) - //! t(ap(fs, xs)) == ap(t(fs), t(xs)) - //! @endcode - //! - //! [1]: https://wiki.haskell.org/Typeclassopedia#Applicative - template <typename A> - struct Applicative; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/comonad.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/comonad.hpp deleted file mode 100644 index b2693078b0..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/comonad.hpp +++ /dev/null @@ -1,111 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Comonad`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_COMONAD_HPP -#define BOOST_HANA_FWD_CONCEPT_COMONAD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: We use a multiline C++ comment because there's a double backslash - // symbol in the documentation (for LaTeX), which triggers - // warning: multi-line comment [-Wcomment] - // on GCC. - - /*! - @ingroup group-concepts - @defgroup group-Comonad Comonad - The `Comonad` concept represents context-sensitive computations and - data. - - Formally, the Comonad concept is dual to the Monad concept. - But unless you're a mathematician, you don't care about that and it's - fine. So intuitively, a Comonad represents context sensitive values - and computations. First, Comonads make it possible to extract - context-sensitive values from their context with `extract`. - In contrast, Monads make it possible to wrap raw values into - a given context with `lift` (from Applicative). - - Secondly, Comonads make it possible to apply context-sensitive values - to functions accepting those, and to return the result as a - context-sensitive value using `extend`. In contrast, Monads make - it possible to apply a monadic value to a function accepting a normal - value and returning a monadic value, and to return the result as a - monadic value (with `chain`). - - Finally, Comonads make it possible to wrap a context-sensitive value - into an extra layer of context using `duplicate`, while Monads make - it possible to take a value with an extra layer of context and to - strip it with `flatten`. - - Whereas `lift`, `chain` and `flatten` from Applicative and Monad have - signatures - \f{align*}{ - \mathtt{lift}_M &: T \to M(T) \\ - \mathtt{chain} &: M(T) \times (T \to M(U)) \to M(U) \\ - \mathtt{flatten} &: M(M(T)) \to M(T) - \f} - - `extract`, `extend` and `duplicate` from Comonad have signatures - \f{align*}{ - \mathtt{extract} &: W(T) \to T \\ - \mathtt{extend} &: W(T) \times (W(T) \to U) \to W(U) \\ - \mathtt{duplicate} &: W(T) \to W(W(T)) - \f} - - Notice how the "arrows" are reversed. This symmetry is essentially - what we mean by Comonad being the _dual_ of Monad. - - @note - The [Typeclassopedia][1] is a nice Haskell-oriented resource for further - reading about Comonads. - - - Minimal complete definition - --------------------------- - `extract` and (`extend` or `duplicate`) satisfying the laws below. - A `Comonad` must also be a `Functor`. - - - Laws - ---- - For all Comonads `w`, the following laws must be satisfied: - @code - extract(duplicate(w)) == w - transform(duplicate(w), extract) == w - duplicate(duplicate(w)) == transform(duplicate(w), duplicate) - @endcode - - @note - There are several equivalent ways of defining Comonads, and this one - is just one that was picked arbitrarily for simplicity. - - - Refined concept - --------------- - 1. Functor\n - Every Comonad is also required to be a Functor. At first, one might think - that it should instead be some imaginary concept CoFunctor. However, it - turns out that a CoFunctor is the same as a `Functor`, hence the - requirement that a `Comonad` also is a `Functor`. - - - Concrete models - --------------- - `hana::lazy` - - [1]: https://wiki.haskell.org/Typeclassopedia#Comonad - - */ - template <typename W> - struct Comonad; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_COMONAD_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/comparable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/comparable.hpp deleted file mode 100644 index 9624c87038..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/comparable.hpp +++ /dev/null @@ -1,160 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Comparable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Comparable Comparable - //! The `Comparable` concept defines equality and inequality. - //! - //! Intuitively, `Comparable` objects must define a binary predicate named - //! `equal` that returns whether both objects represent the same abstract - //! value. In other words, `equal` must check for deep equality. Since - //! "representing the same abstract value" is difficult to express - //! formally, the exact meaning of equality is partially left to - //! interpretation by the programmer with the following guidelines:\n - //! 1. Equality should be compatible with copy construction; copy - //! constructing a value yields an `equal` value. - //! 2. Equality should be independent of representation; an object - //! representing a fraction as `4/8` should be `equal` to an object - //! representing a fraction as `2/4`, because they both represent - //! the mathematical object `1/2`. - //! - //! Moreover, `equal` must exhibit properties that make it intuitive to - //! use for determining the equivalence of objects, which is formalized - //! by the laws for `Comparable`. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! 1. `equal`\n - //! When `equal` is defined, `not_equal` is implemented by default as its - //! complement. For all objects `x`, `y` of a `Comparable` tag, - //! @code - //! not_equal(x, y) == not_(equal(x, y)) - //! @endcode - //! - //! - //! Laws - //! ---- - //! `equal` must define an [equivalence relation][1], and `not_equal` must - //! be its complement. In other words, for all objects `a`, `b`, `c` with - //! a `Comparable` tag, the following must hold: - //! @code - //! equal(a, a) // Reflexivity - //! if equal(a, b) then equal(b, a) // Symmetry - //! if equal(a, b) && equal(b, c) then equal(a, c) // Transitivity - //! not_equal(a, b) is equivalent to not_(equal(a, b)) - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant`, `hana::map`, `hana::optional`, `hana::pair`, - //! `hana::range`, `hana::set`, `hana::string`, `hana::tuple`, - //! `hana::type` - //! - //! - //! Free model for `EqualityComparable` data types - //! ---------------------------------------------- - //! Two data types `T` and `U` that model the cross-type EqualityComparable - //! concept presented in [N3351][2] automatically model the `Comparable` - //! concept by setting - //! @code - //! equal(x, y) = (x == y) - //! @endcode - //! Note that this also makes EqualityComparable types in the - //! [usual sense][3] models of `Comparable` in the same way. - //! - //! - //! Equality-preserving functions - //! ----------------------------- - //! Let `A` and `B` be two `Comparable` tags. A function @f$f : A \to B@f$ - //! is said to be equality-preserving if it preserves the structure of the - //! `Comparable` concept, which can be rigorously stated as follows. For - //! all objects `x`, `y` of tag `A`, - //! @code - //! if equal(x, y) then equal(f(x), f(y)) - //! @endcode - //! Equivalently, we simply require that `f` is a function in the usual - //! mathematical sense. Another property is [injectivity][4], which can be - //! viewed as being a "lossless" mapping. This property can be stated as - //! @code - //! if equal(f(x), f(y)) then equal(x, y) - //! @endcode - //! This is equivalent to saying that `f` maps distinct elements to - //! distinct elements, hence the "lossless" analogy. In other words, `f` - //! will not collapse distinct elements from its domain into a single - //! element in its image, thus losing information. - //! - //! These functions are very important, especially equality-preserving - //! ones, because they allow us to reason simply about programs. Also - //! note that the property of being equality-preserving is taken for - //! granted in mathematics because it is part of the definition of a - //! function. We feel it is important to make the distinction here - //! because programming has evolved differently and as a result - //! programmers are used to work with functions that do not preserve - //! equality. - //! - //! - //! Cross-type version of the methods - //! --------------------------------- - //! The `equal` and `not_equal` methods are "overloaded" to handle - //! distinct tags with certain properties. Specifically, they are - //! defined for _distinct_ tags `A` and `B` such that - //! 1. `A` and `B` share a common tag `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `Comparable` when taken individually - //! 3. @f$ \mathtt{to<C>} : A \to C @f$ and @f$\mathtt{to<C>} : B \to C@f$ - //! are both equality-preserving and injective (i.e. they are embeddings), - //! as determined by the `is_embedding` metafunction. - //! - //! The method definitions for tags satisfying the above properties are - //! @code - //! equal(x, y) = equal(to<C>(x), to<C>(y)) - //! not_equal(x, y) = not_equal(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Important note: special behavior of `equal` - //! ------------------------------------------- - //! In the context of programming with heterogeneous values, it is useful - //! to have unrelated objects compare `false` instead of triggering an - //! error. For this reason, `equal` adopts a special behavior for - //! unrelated objects of tags `T` and `U` that do not satisfy the above - //! requirements for the cross-type overloads. Specifically, when `T` and - //! `U` are unrelated (i.e. `T` can't be converted to `U` and vice-versa), - //! comparing objects with those tags yields a compile-time false value. - //! This has the effect that unrelated objects like `float` and - //! `std::string` will compare false, while comparing related objects that - //! can not be safely embedded into the same super structure (like - //! `long long` and `float` because of the precision loss) will trigger a - //! compile-time assertion. Also note that for any tag `T` for which the - //! minimal complete definition of `Comparable` is not provided, a - //! compile-time assertion will also be triggered because `T` and `T` - //! trivially share the common tag `T`, which is the expected behavior. - //! This design choice aims to provide more flexibility for comparing - //! objects, while still rejecting usage patterns that are most likely - //! programming errors. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition - //! [2]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf - //! [3]: http://en.cppreference.com/w/cpp/concept/EqualityComparable - //! [4]: http://en.wikipedia.org/wiki/Injective_function - template <typename T> - struct Comparable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/constant.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/constant.hpp deleted file mode 100644 index bab44a7cb2..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/constant.hpp +++ /dev/null @@ -1,210 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Constant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP -#define BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Constant Constant - //! The `Constant` concept represents data that can be manipulated at - //! compile-time. - //! - //! At its core, `Constant` is simply a generalization of the principle - //! behind `std::integral_constant` to all types that can be constructed - //! at compile-time, i.e. to all types with a `constexpr` constructor - //! (also called [Literal types][1]). More specifically, a `Constant` is - //! an object from which a `constexpr` value may be obtained (through the - //! `value` method) regardless of the `constexpr`ness of the object itself. - //! - //! All `Constant`s must be somewhat equivalent, in the following sense. - //! Let `C(T)` and `D(U)` denote the tags of `Constant`s holding objects - //! of type `T` and `U`, respectively. Then, an object with tag `D(U)` - //! must be convertible to an object with tag `C(T)` whenever `U` is - //! convertible to `T`, as determined by `is_convertible`. The - //! interpretation here is that a `Constant` is just a box holding - //! an object of some type, and it should be possible to swap between - //! boxes whenever the objects inside the boxes can be swapped. - //! - //! Because of this last requirement, one could be tempted to think that - //! specialized "boxes" like `std::integral_constant` are prevented from - //! being `Constant`s because they are not able to hold objects of any - //! type `T` (`std::integral_constant` may only hold integral types). - //! This is false; the requirement should be interpreted as saying that - //! whenever `C(T)` is _meaningful_ (e.g. only when `T` is integral for - //! `std::integral_constant`) _and_ there exists a conversion from `U` - //! to `T`, then a conversion from `D(U)` to `C(T)` should also exist. - //! The precise requirements for being a `Constant` are embodied in the - //! following laws. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `value` and `to`, satisfying the laws below. - //! - //! - //! Laws - //! ---- - //! Let `c` be an object of with tag `C`, which represents a `Constant` - //! holding an object with tag `T`. The first law ensures that the value - //! of the wrapped object is always a constant expression by requiring - //! the following to be well-formed: - //! @code - //! constexpr auto x = hana::value<decltype(c)>(); - //! @endcode - //! - //! This means that the `value` function must return an object that can - //! be constructed at compile-time. It is important to note how `value` - //! only receives the type of the object and not the object itself. - //! This is the core of the `Constant` concept; it means that the only - //! information required to implement `value` must be stored in the _type_ - //! of its argument, and hence be available statically. - //! - //! The second law that must be satisfied ensures that `Constant`s are - //! basically dumb boxes, which makes it possible to provide models for - //! many concepts without much work from the user. The law simply asks - //! for the following expression to be valid: - //! @code - //! to<C>(i) - //! @endcode - //! where, `i` is an _arbitrary_ `Constant` holding an internal value - //! with a tag that can be converted to `T`, as determined by the - //! `hana::is_convertible` metafunction. In other words, whenever `U` is - //! convertible to `T`, a `Constant` holding a `U` is convertible to - //! a `Constant` holding a `T`, if such a `Constant` can be created. - //! - //! Finally, the tag `C` must provide a nested `value_type` alias to `T`, - //! which allows us to query the tag of the inner value held by objects - //! with tag `C`. In other words, the following must be true for any - //! object `c` with tag `C`: - //! @code - //! std::is_same< - //! C::value_type, - //! tag_of<decltype(hana::value(c))>::type - //! >::value - //! @endcode - //! - //! - //! Refined concepts - //! ---------------- - //! In certain cases, a `Constant` can automatically be made a model of - //! another concept. In particular, if a `Constant` `C` is holding an - //! object of tag `T`, and if `T` models a concept `X`, then `C` may - //! in most cases model `X` by simply performing whatever operation is - //! required on its underlying value, and then wrapping the result back - //! in a `C`. - //! - //! More specifically, if a `Constant` `C` has an underlying value - //! (`C::value_type`) which is a model of `Comparable`, `Orderable`, - //! `Logical`, or `Monoid` up to `EuclideanRing`, then `C` must also - //! be a model of those concepts. In other words, when `C::value_type` - //! models one of the listed concepts, `C` itself must also model that - //! concept. However, note that free models are provided for all of - //! those concepts, so no additional work must be done. - //! - //! While it would be possible in theory to provide models for concepts - //! like `Foldable` too, only a couple of concepts are useful to have as - //! `Constant` in practice. Providing free models for the concepts listed - //! above is useful because it allows various types of integral constants - //! (`std::integral_constant`, `mpl::integral_c`, etc...) to easily have - //! models for them just by defining the `Constant` concept. - //! - //! @remark - //! An interesting observation is that `Constant` is actually the - //! canonical embedding of the subcategory of `constexpr` things - //! into the Hana category, which contains everything in this library. - //! Hence, whatever is true in that subcategory is also true here, via - //! this functor. This is why we can provide models of any concept that - //! works on `constexpr` things for Constants, by simply passing them - //! through that embedding. - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Provided conversion to the tag of the underlying value - //! ------------------------------------------------------ - //! Any `Constant` `c` holding an underlying value of tag `T` is - //! convertible to any tag `U` such that `T` is convertible to `U`. - //! Specifically, the conversion is equivalent to - //! @code - //! to<U>(c) == to<U>(value<decltype(c)>()) - //! @endcode - //! - //! Also, those conversions are marked as an embedding whenever the - //! conversion of underlying types is an embedding. This is to allow - //! Constants to inter-operate with `constexpr` objects easily: - //! @code - //! plus(int_c<1>, 1) == 2 - //! @endcode - //! - //! Strictly speaking, __this is sometimes a violation__ of what it means - //! to be an embedding. Indeed, while there exists an embedding from any - //! Constant to a `constexpr` object (since Constant is just the canonical - //! inclusion), there is no embedding from a Constant to a runtime - //! object since we would lose the ability to define the `value` method - //! (the `constexpr`ness of the object would have been lost). Since there - //! is no way to distinguish `constexpr` and non-`constexpr` objects based - //! on their type, Hana has no way to know whether the conversion is to a - //! `constexpr` object of not. In other words, the `to` method has no way - //! to differentiate between - //! @code - //! constexpr int i = hana::to<int>(int_c<1>); - //! @endcode - //! which is an embedding, and - //! @code - //! int i = hana::to<int>(int_c<1>); - //! @endcode - //! - //! which isn't. To be on the safer side, we could mark the conversion - //! as not-an-embedding. However, if e.g. the conversion from - //! `integral_constant_tag<int>` to `int` was not marked as an embedding, - //! we would have to write `plus(to<int>(int_c<1>), 1)` instead of just - //! `plus(int_c<1>, 1)`, which is cumbersome. Hence, the conversion is - //! marked as an embedding, but this also means that code like - //! @code - //! int i = 1; - //! plus(int_c<1>, i); - //! @endcode - //! will be considered valid, which implicitly loses the fact that - //! `int_c<1>` is a Constant, and hence does not follow the usual rules - //! for cross-type operations in Hana. - //! - //! - //! Provided common data type - //! ------------------------- - //! Because of the requirement that `Constant`s be interchangeable when - //! their contents are compatible, two `Constant`s `A` and `B` will have - //! a common data type whenever `A::value_type` and `B::value_type` have - //! one. Their common data type is an unspecified `Constant` `C` such - //! that `C::value_type` is exactly `common_t<A::value_type, B::value_type>`. - //! A specialization of the `common` metafunction is provided for - //! `Constant`s to reflect this. - //! - //! In the same vein, a common data type is also provided from any - //! constant `A` to a type `T` such that `A::value_type` and `T` share - //! a common type. The common type between `A` and `T` is obviously the - //! common type between `A::value_type` and `T`. As explained above in - //! the section on conversions, this is sometimes a violation of the - //! definition of a common type, because there must be an embedding - //! to the common type, which is not always the case. For the same - //! reasons as explained above, this common type is still provided. - //! - //! - //! [1]: http://en.cppreference.com/w/cpp/concept/LiteralType - template <typename C> - struct Constant; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/euclidean_ring.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/euclidean_ring.hpp deleted file mode 100644 index 8b8744c29d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/euclidean_ring.hpp +++ /dev/null @@ -1,117 +0,0 @@ -/*! -@file -Forward declares `boost::hana::EuclideanRing`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP -#define BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-EuclideanRing Euclidean Ring - //! The `EuclideanRing` concept represents a commutative `Ring` that - //! can also be endowed with a division algorithm. - //! - //! A Ring defines a binary operation often called _multiplication_ that - //! can be used to combine two elements of the ring into a new element of - //! the ring. An [Euclidean ring][1], also called an Euclidean domain, adds - //! the ability to define a special function that generalizes the Euclidean - //! division of integers. - //! - //! However, an Euclidean ring must also satisfy one more property, which - //! is that of having no non-zero zero divisors. In a Ring `(R, +, *)`, it - //! follows quite easily from the axioms that `x * 0 == 0` for any ring - //! element `x`. However, there is nothing that mandates `0` to be the - //! only ring element sending other elements to `0`. Hence, in some Rings, - //! it is possible to have elements `x` and `y` such that `x * y == 0` - //! while not having `x == 0` nor `y == 0`. We call these elements divisors - //! of zero, or zero divisors. For example, this situation arises in the - //! Ring of integers modulo 4 (the set `{0, 1, 2, 3}`) with addition and - //! multiplication `mod 4` as binary operations. In this case, we have that - //! @code - //! 2 * 2 == 4 - //! == 0 (mod 4) - //! @endcode - //! even though `2 != 0 (mod 4)`. - //! - //! Following this line of thought, an Euclidean ring requires its only - //! zero divisor is zero itself. In other words, the multiplication in an - //! Euclidean won't send two non-zero elements to zero. Also note that - //! since multiplication in a `Ring` is not necessarily commutative, it - //! is not always the case that - //! @code - //! x * y == 0 implies y * x == 0 - //! @endcode - //! To be rigorous, we should then distinguish between elements that are - //! zero divisors when multiplied to the right and to the left. - //! Fortunately, the concept of an Euclidean ring requires the Ring - //! multiplication to be commutative. Hence, - //! @code - //! x * y == y * x - //! @endcode - //! and we do not have to distinguish between left and right zero divisors. - //! - //! Typical examples of Euclidean rings include integers and polynomials - //! over a field. The method names used here refer to the Euclidean ring - //! of integers under the usual addition, multiplication and division - //! operations. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `div` and `mod` satisfying the laws below - //! - //! - //! Laws - //! ---- - //! To simplify the reading, we will use the `+`, `*`, `/` and `%` - //! operators with infix notation to denote the application of the - //! corresponding methods in Monoid, Group, Ring and EuclideanRing. - //! For all objects `a` and `b` of an `EuclideanRing` `R`, the - //! following laws must be satisfied: - //! @code - //! a * b == b * a // commutativity - //! (a / b) * b + a % b == a if b is non-zero - //! zero<R>() % b == zero<R>() if b is non-zero - //! @endcode - //! - //! - //! Refined concepts - //! ---------------- - //! `Monoid`, `Group`, `Ring` - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Free model for non-boolean integral data types - //! ---------------------------------------------- - //! A data type `T` is integral if `std::is_integral<T>::%value` is true. - //! For a non-boolean integral data type `T`, a model of `EuclideanRing` - //! is automatically defined by using the `Ring` model provided for - //! arithmetic data types and setting - //! @code - //! div(x, y) = (x / y) - //! mod(x, y) = (x % y) - //! @endcode - //! - //! @note - //! The rationale for not providing an EuclideanRing model for `bool` is - //! the same as for not providing Monoid, Group and Ring models. - //! - //! - //! [1]: https://en.wikipedia.org/wiki/Euclidean_domain - template <typename R> - struct EuclideanRing; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/foldable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/foldable.hpp deleted file mode 100644 index 09de170455..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/foldable.hpp +++ /dev/null @@ -1,141 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Foldable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Foldable Foldable - //! The `Foldable` concept represents data structures that can be reduced - //! to a single value. - //! - //! Generally speaking, folding refers to the concept of summarizing a - //! complex structure as a single value, by successively applying a - //! binary operation which reduces two elements of the structure to a - //! single value. Folds come in many flavors; left folds, right folds, - //! folds with and without an initial reduction state, and their monadic - //! variants. This concept is able to express all of these fold variants. - //! - //! Another way of seeing `Foldable` is as data structures supporting - //! internal iteration with the ability to accumulate a result. By - //! internal iteration, we mean that the _loop control_ is in the hand - //! of the structure, not the caller. Hence, it is the structure who - //! decides when the iteration stops, which is normally when the whole - //! structure has been consumed. Since C++ is an eager language, this - //! requires `Foldable` structures to be finite, or otherwise one would - //! need to loop indefinitely to consume the whole structure. - //! - //! @note - //! While the fact that `Foldable` only works for finite structures may - //! seem overly restrictive in comparison to the Haskell definition of - //! `Foldable`, a finer grained separation of the concepts should - //! mitigate the issue. For iterating over possibly infinite data - //! structures, see the `Iterable` concept. For searching a possibly - //! infinite data structure, see the `Searchable` concept. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `fold_left` or `unpack` - //! - //! However, please note that a minimal complete definition provided - //! through `unpack` will be much more compile-time efficient than one - //! provided through `fold_left`. - //! - //! - //! Concrete models - //! --------------- - //! `hana::map`, `hana::optional`, `hana::pair`, `hana::set`, - //! `hana::range`, `hana::tuple` - //! - //! - //! @anchor Foldable-lin - //! The linearization of a `Foldable` - //! --------------------------------- - //! Intuitively, for a `Foldable` structure `xs`, the _linearization_ of - //! `xs` is the sequence of all the elements in `xs` as if they had been - //! put in a list: - //! @code - //! linearization(xs) = [x1, x2, ..., xn] - //! @endcode - //! - //! Note that it is always possible to produce such a linearization - //! for a finite `Foldable` by setting - //! @code - //! linearization(xs) = fold_left(xs, [], flip(prepend)) - //! @endcode - //! for an appropriate definition of `[]` and `prepend`. The notion of - //! linearization is useful for expressing various properties of - //! `Foldable` structures, and is used across the documentation. Also - //! note that `Iterable`s define an [extended version](@ref Iterable-lin) - //! of this allowing for infinite structures. - //! - //! - //! Compile-time Foldables - //! ---------------------- - //! A compile-time `Foldable` is a `Foldable` whose total length is known - //! at compile-time. In other words, it is a `Foldable` whose `length` - //! method returns a `Constant` of an unsigned integral type. When - //! folding a compile-time `Foldable`, the folding can be unrolled, - //! because the final number of steps of the algorithm is known at - //! compile-time. - //! - //! Additionally, the `unpack` method is only available to compile-time - //! `Foldable`s. This is because the return _type_ of `unpack` depends - //! on the number of objects in the structure. Being able to resolve - //! `unpack`'s return type at compile-time hence requires the length of - //! the structure to be known at compile-time too. - //! - //! __In the current version of the library, only compile-time `Foldable`s - //! are supported.__ While it would be possible in theory to support - //! runtime `Foldable`s too, doing so efficiently requires more research. - //! - //! - //! Provided conversion to `Sequence`s - //! ---------------------------------- - //! Given a tag `S` which is a `Sequence`, an object whose tag is a model - //! of the `Foldable` concept can be converted to an object of tag `S`. - //! In other words, a `Foldable` can be converted to a `Sequence` `S`, by - //! simply taking the linearization of the `Foldable` and creating the - //! sequence with that. More specifically, given a `Foldable` `xs` with a - //! linearization of `[x1, ..., xn]` and a `Sequence` tag `S`, `to<S>(xs)` - //! is equivalent to `make<S>(x1, ..., xn)`. - //! @include example/foldable/to.cpp - //! - //! - //! Free model for builtin arrays - //! ----------------------------- - //! Builtin arrays whose size is known can be folded as-if they were - //! homogeneous tuples. However, note that builtin arrays can't be - //! made more than `Foldable` (e.g. `Iterable`) because they can't - //! be empty and they also can't be returned from functions. - //! - //! - //! @anchor monadic-folds - //! Primer on monadic folds - //! ----------------------- - //! A monadic fold is a fold in which subsequent calls to the binary - //! function are chained with the monadic `chain` operator of the - //! corresponding Monad. This allows a structure to be folded in a - //! custom monadic context. For example, performing a monadic fold with - //! the `hana::optional` monad would require the binary function to return - //! the result as a `hana::optional`, and the fold would abort and return - //! `nothing` whenever one of the accumulation step would fail (i.e. - //! return `nothing`). If, however, all the reduction steps succeed, - //! then `just` the result would be returned. Different monads will of - //! course result in different effects. - template <typename T> - struct Foldable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/functor.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/functor.hpp deleted file mode 100644 index f46ad24c73..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/functor.hpp +++ /dev/null @@ -1,139 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Functor`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP -#define BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Functor Functor - //! The `Functor` concept represents types that can be mapped over. - //! - //! Intuitively, a [Functor][1] is some kind of box that can hold generic - //! data and map a function over this data to create a new, transformed - //! box. Because we are only interested in mapping a function over the - //! contents of a black box, the only real requirement for being a functor - //! is to provide a function which can do the mapping, along with a couple - //! of guarantees that the mapping is well-behaved. Those requirements are - //! made precise in the laws below. The pattern captured by `Functor` is - //! very general, which makes it widely useful. A lot of objects can be - //! made `Functor`s in one way or another, the most obvious example being - //! sequences with the usual mapping of the function on each element. - //! While this documentation will not go into much more details about - //! the nature of functors, the [Typeclassopedia][2] is a nice - //! Haskell-oriented resource for such information. - //! - //! Functors are parametric data types which are parameterized over the - //! data type of the objects they contain. Like everywhere else in Hana, - //! this parametricity is only at the documentation level and it is not - //! enforced. - //! - //! In this library, the mapping function is called `transform` after the - //! `std::transform` algorithm, but other programming languages have given - //! it different names (usually `map`). - //! - //! @note - //! The word _functor_ comes from functional programming, where the - //! concept has been used for a while, notably in the Haskell programming - //! language. Haskell people borrowed the term from [category theory][3], - //! which, broadly speaking, is a field of mathematics dealing with - //! abstract structures and transformations between those structures. - //! - //! - //! Minimal complete definitions - //! ---------------------------- - //! 1. `transform`\n - //! When `transform` is specified, `adjust_if` is defined analogously to - //! @code - //! adjust_if(xs, pred, f) = transform(xs, [](x){ - //! if pred(x) then f(x) else x - //! }) - //! @endcode - //! - //! 2. `adjust_if`\n - //! When `adjust_if` is specified, `transform` is defined analogously to - //! @code - //! transform(xs, f) = adjust_if(xs, always(true), f) - //! @endcode - //! - //! - //! Laws - //! ---- - //! Let `xs` be a Functor with tag `F(A)`, - //! \f$ f : A \to B \f$ and - //! \f$ g : B \to C \f$. - //! The following laws must be satisfied: - //! @code - //! transform(xs, id) == xs - //! transform(xs, compose(g, f)) == transform(transform(xs, f), g) - //! @endcode - //! The first line says that mapping the identity function should not do - //! anything, which precludes the functor from doing something nasty - //! behind the scenes. The second line states that mapping the composition - //! of two functions is the same as mapping the first function, and then - //! the second on the result. While the usual functor laws are usually - //! restricted to the above, this library includes other convenience - //! methods and they should satisfy the following equations. - //! Let `xs` be a Functor with tag `F(A)`, - //! \f$ f : A \to A \f$, - //! \f$ \mathrm{pred} : A \to \mathrm{Bool} \f$ - //! for some `Logical` `Bool`, and `oldval`, `newval`, `value` objects - //! of tag `A`. Then, - //! @code - //! adjust(xs, value, f) == adjust_if(xs, equal.to(value), f) - //! adjust_if(xs, pred, f) == transform(xs, [](x){ - //! if pred(x) then f(x) else x - //! }) - //! replace_if(xs, pred, value) == adjust_if(xs, pred, always(value)) - //! replace(xs, oldval, newval) == replace_if(xs, equal.to(oldval), newval) - //! fill(xs, value) == replace_if(xs, always(true), value) - //! @endcode - //! The default definition of the methods will satisfy these equations. - //! - //! - //! Concrete models - //! --------------- - //! `hana::lazy`, `hana::optional`, `hana::tuple` - //! - //! - //! Structure-preserving functions for Functors - //! ------------------------------------------- - //! A mapping between two functors which also preserves the functor - //! laws is called a natural transformation (the term comes from - //! category theory). A natural transformation is a function `f` - //! from a functor `F` to a functor `G` such that for every other - //! function `g` with an appropriate signature and for every object - //! `xs` of tag `F(X)`, - //! @code - //! f(transform(xs, g)) == transform(f(xs), g) - //! @endcode - //! - //! There are several examples of such transformations, like `to<tuple_tag>` - //! when applied to an optional value. Indeed, for any function `g` and - //! `hana::optional` `opt`, - //! @code - //! to<tuple_tag>(transform(opt, g)) == transform(to<tuple_tag>(opt), g) - //! @endcode - //! - //! Of course, natural transformations are not limited to the `to<...>` - //! functions. However, note that any conversion function between Functors - //! should be natural for the behavior of the conversion to be intuitive. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Functor - //! [2]: https://wiki.haskell.org/Typeclassopedia#Functor - //! [3]: http://en.wikipedia.org/wiki/Category_theory - template <typename F> - struct Functor; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/group.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/group.hpp deleted file mode 100644 index 6afec94502..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/group.hpp +++ /dev/null @@ -1,111 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Group`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_GROUP_HPP -#define BOOST_HANA_FWD_CONCEPT_GROUP_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Group Group - //! The `Group` concept represents `Monoid`s where all objects have - //! an inverse w.r.t. the `Monoid`'s binary operation. - //! - //! A [Group][1] is an algebraic structure built on top of a `Monoid` - //! which adds the ability to invert the action of the `Monoid`'s binary - //! operation on any element of the set. Specifically, a `Group` is a - //! `Monoid` `(S, +)` such that every element `s` in `S` has an inverse - //! (say `s'`) which is such that - //! @code - //! s + s' == s' + s == identity of the Monoid - //! @endcode - //! - //! There are many examples of `Group`s, one of which would be the - //! additive `Monoid` on integers, where the inverse of any integer - //! `n` is the integer `-n`. The method names used here refer to - //! exactly this model. - //! - //! - //! Minimal complete definitions - //! ---------------------------- - //! 1. `minus`\n - //! When `minus` is specified, the `negate` method is defaulted by setting - //! @code - //! negate(x) = minus(zero<G>(), x) - //! @endcode - //! - //! 2. `negate`\n - //! When `negate` is specified, the `minus` method is defaulted by setting - //! @code - //! minus(x, y) = plus(x, negate(y)) - //! @endcode - //! - //! - //! Laws - //! ---- - //! For all objects `x` of a `Group` `G`, the following laws must be - //! satisfied: - //! @code - //! plus(x, negate(x)) == zero<G>() // right inverse - //! plus(negate(x), x) == zero<G>() // left inverse - //! @endcode - //! - //! - //! Refined concept - //! --------------- - //! `Monoid` - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Free model for non-boolean arithmetic data types - //! ------------------------------------------------ - //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is - //! true. For a non-boolean arithmetic data type `T`, a model of `Group` - //! is automatically defined by setting - //! @code - //! minus(x, y) = (x - y) - //! negate(x) = -x - //! @endcode - //! - //! @note - //! The rationale for not providing a Group model for `bool` is the same - //! as for not providing a `Monoid` model. - //! - //! - //! Structure-preserving functions - //! ------------------------------ - //! Let `A` and `B` be two `Group`s. A function `f : A -> B` is said to - //! be a [Group morphism][2] if it preserves the group structure between - //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, - //! @code - //! f(plus(x, y)) == plus(f(x), f(y)) - //! @endcode - //! Because of the `Group` structure, it is easy to prove that the - //! following will then also be satisfied: - //! @code - //! f(negate(x)) == negate(f(x)) - //! f(zero<A>()) == zero<B>() - //! @endcode - //! Functions with these properties interact nicely with `Group`s, which - //! is why they are given such a special treatment. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Group_(mathematics) - //! [2]: http://en.wikipedia.org/wiki/Group_homomorphism - template <typename G> - struct Group; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_GROUP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/hashable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/hashable.hpp deleted file mode 100644 index 2fc4977ba9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/hashable.hpp +++ /dev/null @@ -1,68 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Hashable`. - -@copyright Louis Dionne 2016 -@copyright Jason Rice 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) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Hashable Hashable - //! The `Hashable` concept represents objects that can be normalized to - //! a type-level hash. - //! - //! In day to day programming, hashes are very important as a way to - //! efficiently lookup objects in maps. While the implementation of - //! maps is very different, the same idea of using hashes for efficient - //! lookup applies in metaprogramming. The `Hashable` concept represents - //! objects that can be summarized (possibly with loss of information) to - //! a type, in a way suitable for use in hash-based data structures. Of - //! course, in order for a hash to be well-behaved, it must obey some laws - //! that are explained below. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `hash`, satisfying the laws below - //! - //! - //! Laws - //! ---- - //! First, `hana::hash` must return a `hana::type`. Furthermore, for any - //! two `Hashable` objects `x` and `y`, it must be the case that - //! @code - //! x == y implies hash(x) == hash(y) - //! @endcode - //! - //! where `==` denotes `hana::equal`. In other words, any two objects that - //! compare equal (with `hana::equal`) must also have the same hash. - //! However, the reverse is not true, and two different objects may have - //! the same hash. This situation of two different objects having the same - //! hash is called a _collision_. - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant`, `hana::type`, `hana::string` - //! - //! - //! Free model for `IntegralConstant`s - //! ---------------------------------- - //! Any `IntegralConstant` is `Hashable`, by normalizing its value to a - //! `hana::integral_constant`. The type of the value held in the normalized - //! `integral_constant` is `unsigned long long` for unsigned integral - //! types, and `signed long long` for signed integral types. - template <typename T> - struct Hashable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/integral_constant.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/integral_constant.hpp deleted file mode 100644 index 161062e2be..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/integral_constant.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*! -@file -Forward declares `boost::hana::IntegralConstant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! The `IntegralConstant` concept represents compile-time integral values. - //! - //! The `IntegralConstant` concept represents objects that hold a - //! `constexpr` value of an integral type. In other words, it describes - //! the essential functionality provided by `std::integral_constant`. - //! An `IntegralConstant` is also just a special kind of `Constant` - //! whose inner value is of an integral type. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! The requirements for being an `IntegralConstant` are quite simple. - //! First, an `IntegralConstant` `C` must be a `Constant` such that - //! `Tag::value_type` is an integral type, where `Tag` is the tag of `C`. - //! - //! Secondly, `C` must have a nested `static constexpr` member named - //! `value`, such that the following code is valid: - //! @code - //! constexpr auto v = C::value; - //! @endcode - //! Because of the requirement that `Tag::value_type` be an integral type, - //! it follows that `C::value` must be an integral value. - //! - //! Finally, it is necessary to specialize the `IntegralConstant` template - //! in the `boost::hana` namespace to tell Hana that a type is a model - //! of `IntegralConstant`: - //! @code - //! namespace boost { namespace hana { - //! template <> - //! struct IntegralConstant<your_custom_tag> { - //! static constexpr bool value = true; - //! }; - //! }} - //! @endcode - //! - //! - //! Refined concept - //! --------------- - //! 1. `Constant` (free implementation of `value`)\n - //! The `value` function required to be a `Constant` can be implemented - //! as follows for `IntegralConstant`s: - //! @code - //! value<C>() == C::value - //! @endcode - //! The `to` function must still be provided explicitly for the model - //! of `Constant` to be complete. - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - template <typename C> - struct IntegralConstant; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/iterable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/iterable.hpp deleted file mode 100644 index 59c8520b62..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/iterable.hpp +++ /dev/null @@ -1,149 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Iterable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Iterable Iterable - //! The `Iterable` concept represents data structures supporting external - //! iteration. - //! - //! Intuitively, an `Iterable` can be seen as a kind of container whose - //! elements can be pulled out one at a time. An `Iterable` also provides - //! a way to know when the _container_ is empty, i.e. when there are no - //! more elements to pull out. - //! - //! Whereas `Foldable` represents data structures supporting internal - //! iteration with the ability to accumulate a result, the `Iterable` - //! concept allows inverting the control of the iteration. This is more - //! flexible than `Foldable`, since it allows iterating over only some - //! part of the structure. This, in turn, allows `Iterable` to work on - //! infinite structures, while trying to fold such a structure would - //! never finish. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `at`, `drop_front` and `is_empty` - //! - //! - //! @anchor Iterable-lin - //! The linearization of an `Iterable` - //! ---------------------------------- - //! Intuitively, for an `Iterable` structure `xs`, the _linearization_ of - //! `xs` is the sequence of all the elements in `xs` as if they had been - //! put in a (possibly infinite) list: - //! @code - //! linearization(xs) = [x1, x2, x3, ...] - //! @endcode - //! - //! The `n`th element of the linearization of an `Iterable` can be - //! accessed with the `at` function. In other words, `at(xs, n) == xn`. - //! - //! Note that this notion is precisely the extension of the [linearization] - //! (@ref Foldable-lin) notion of `Foldable`s to the infinite case. This - //! notion is useful for expressing various properties of `Iterable`s, - //! and is used for that elsewhere in the documentation. - //! - //! - //! Compile-time `Iterable`s - //! ------------------------ - //! A _compile-time_ `Iterable` is an `Iterable` for which `is_empty` - //! returns a compile-time `Logical`. These structures allow iteration - //! to be done at compile-time, in the sense that the "loop" doing the - //! iteration can be unrolled because the total length of the structure - //! is kown at compile-time. - //! - //! In particular, note that being a compile-time `Iterable` has nothing - //! to do with being finite or infinite. For example, it would be possible - //! to create a sequence representing the Pythagorean triples as - //! `integral_constant`s. Such a sequence would be infinite, but iteration - //! on the sequence would still be done at compile-time. However, if one - //! tried to iterate over _all_ the elements of the sequence, the compiler - //! would loop indefinitely, in contrast to your program looping - //! indefinitely if the sequence was a runtime one. - //! - //! __In the current version of the library, only compile-time `Iterable`s - //! are supported.__ While it would be possible in theory to support - //! runtime `Iterable`s, doing it efficiently is the subject of some - //! research. In particular, follow [this issue][1] for the current - //! status of runtime `Iterable`s. - //! - //! - //! Laws - //! ---- - //! First, we require the equality of two `Iterable`s to be related to the - //! equality of the elements in their linearizations. More specifically, - //! if `xs` and `ys` are two `Iterable`s of data type `It`, then - //! @code - //! xs == ys => at(xs, i) == at(ys, i) for all i - //! @endcode - //! - //! This conveys that two `Iterable`s must have the same linearization - //! in order to be considered equal. - //! - //! Secondly, since every `Iterable` is also a `Searchable`, we require - //! the models of `Iterable` and `Searchable` to be consistent. This is - //! made precise by the following laws. For any `Iterable` `xs` with a - //! linearization of `[x1, x2, x3, ...]`, - //! @code - //! any_of(xs, equal.to(z)) <=> xi == z - //! @endcode - //! for some _finite_ index `i`. Furthermore, - //! @code - //! find_if(xs, pred) == just(the first xi such that pred(xi) is satisfied) - //! @endcode - //! or `nothing` if no such `xi` exists. - //! - //! - //! Refined concepts - //! ---------------- - //! 1. `Searchable` (free model)\n - //! Any `Iterable` gives rise to a model of `Searchable`, where the keys - //! and the values are both the elements in the structure. Searching for - //! a key is just doing a linear search through the elements of the - //! structure. - //! @include example/iterable/searchable.cpp - //! - //! 2. `Foldable` for finite `Iterable`s\n - //! Every finite `Iterable` gives rise to a model of `Foldable`. For - //! these models to be consistent, we require the models of both `Foldable` - //! and `Iterable` to have the same linearization. - //! - //! @note - //! As explained above, `Iterable`s are also `Searchable`s and their - //! models have to be consistent. By the laws presented here, it also - //! means that the `Foldable` model for finite `Iterable`s has to be - //! consistent with the `Searchable` model. - //! - //! For convenience, finite `Iterable`s must only provide a definition of - //! `length` to model the `Foldable` concept; defining the more powerful - //! `unpack` or `fold_left` is not necessary (but still possible). The - //! default implementation of `unpack` derived from `Iterable` + `length` - //! uses the fact that `at(xs, i)` denotes the `i`th element of `xs`'s - //! linearization, and that the linearization of a finite `Iterable` must - //! be the same as its linearization as a `Foldable`. - //! - //! - //! Concrete models - //! --------------- - //! `hana::tuple`, `hana::string`, `hana::range` - //! - //! - //! [1]: https://github.com/boostorg/hana/issues/40 - template <typename It> - struct Iterable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/logical.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/logical.hpp deleted file mode 100644 index f9cfde986c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/logical.hpp +++ /dev/null @@ -1,166 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Logical`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP -#define BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Logical Logical - //! The `Logical` concept represents types with a truth value. - //! - //! Intuitively, a `Logical` is just a `bool`, or something that can act - //! like one. However, in the context of programming with heterogeneous - //! objects, it becomes extremely important to distinguish between those - //! objects whose truth value is known at compile-time, and those whose - //! truth value is only known at runtime. The reason why this is so - //! important is because it is possible to branch at compile-time on - //! a condition whose truth value is known at compile-time, and hence - //! the return type of the enclosing function can depend on that truth - //! value. However, if the truth value is only known at runtime, then - //! the compiler has to compile both branches (because any or both of - //! them may end up being used), which creates the additional requirement - //! that both branches must evaluate to the same type. - //! - //! More specifically, `Logical` (almost) represents a [boolean algebra][1], - //! which is a mathematical structure encoding the usual properties that - //! allow us to reason with `bool`. The exact properties that must be - //! satisfied by any model of `Logical` are rigorously stated in the laws - //! below. - //! - //! - //! Truth, falsity and logical equivalence - //! -------------------------------------- - //! A `Logical` `x` is said to be _true-valued_, or sometimes also just - //! _true_ as an abuse of notation, if - //! @code - //! if_(x, true, false) == true - //! @endcode - //! - //! Similarly, `x` is _false-valued_, or sometimes just _false_, if - //! @code - //! if_(x, true, false) == false - //! @endcode - //! - //! This provides a standard way of converting any `Logical` to a straight - //! `bool`. The notion of truth value suggests another definition, which - //! is that of logical equivalence. We will say that two `Logical`s `x` - //! and `y` are _logically equivalent_ if they have the same truth value. - //! To denote that some expressions `p` and `q` of a Logical data type are - //! logically equivalent, we will sometimes also write - //! @code - //! p if and only if q - //! @endcode - //! which is very common in mathematics. The intuition behind this notation - //! is that whenever `p` is true-valued, then `q` should be; but when `p` - //! is false-valued, then `q` should be too. Hence, `p` should be - //! true-valued when (and only when) `q` is true-valued. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `eval_if`, `not_` and `while_` - //! - //! All the other functions can be defined in those terms: - //! @code - //! if_(cond, x, y) = eval_if(cond, lazy(x), lazy(y)) - //! and_(x, y) = if_(x, y, x) - //! or_(x, y) = if_(x, x, y) - //! etc... - //! @endcode - //! - //! - //! Laws - //! ---- - //! As outlined above, the `Logical` concept almost represents a boolean - //! algebra. The rationale for this laxity is to allow things like integers - //! to act like `Logical`s, which is aligned with C++, even though they do - //! not form a boolean algebra. Even though we depart from the usual - //! axiomatization of boolean algebras, we have found through experience - //! that the definition of a Logical given here is largely compatible with - //! intuition. - //! - //! The following laws must be satisfied for any data type `L` modeling - //! the `Logical` concept. Let `a`, `b` and `c` be objects of a `Logical` - //! data type, and let `t` and `f` be arbitrary _true-valued_ and - //! _false-valued_ `Logical`s of that data type, respectively. Then, - //! @code - //! // associativity - //! or_(a, or_(b, c)) == or_(or_(a, b), c) - //! and_(a, and_(b, c)) == and_(and_(a, b), c) - //! - //! // equivalence through commutativity - //! or_(a, b) if and only if or_(b, a) - //! and_(a, b) if and only if and_(b, a) - //! - //! // absorption - //! or_(a, and_(a, b)) == a - //! and_(a, or_(a, b)) == a - //! - //! // left identity - //! or_(a, f) == a - //! and_(a, t) == a - //! - //! // distributivity - //! or_(a, and_(b, c)) == and_(or_(a, b), or_(a, c)) - //! and_(a, or_(b, c)) == or_(and_(a, b), and_(a, c)) - //! - //! // complements - //! or_(a, not_(a)) is true-valued - //! and_(a, not_(a)) is false-valued - //! @endcode - //! - //! > #### Why is the above not a boolean algebra? - //! > If you look closely, you will find that we depart from the usual - //! > boolean algebras because: - //! > 1. we do not require the elements representing truth and falsity to - //! > be unique - //! > 2. we do not enforce commutativity of the `and_` and `or_` operations - //! > 3. because we do not enforce commutativity, the identity laws become - //! > left-identity laws - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Free model for arithmetic data types - //! ------------------------------------ - //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is - //! true. For an arithmetic data type `T`, a model of `Logical` is - //! provided automatically by using the result of the builtin implicit - //! conversion to `bool` as a truth value. Specifically, the minimal - //! complete definition for those data types is - //! @code - //! eval_if(cond, then, else_) = cond ? then(id) : else(id) - //! not_(cond) = static_cast<T>(cond ? false : true) - //! while_(pred, state, f) = equivalent to a normal while loop - //! @endcode - //! - //! > #### Rationale for not providing a model for all contextually convertible to bool data types - //! > The `not_` method can not be implemented in a meaningful way for all - //! > of those types. For example, one can not cast a pointer type `T*` - //! > to bool and then back again to `T*` in a meaningful way. With an - //! > arithmetic type `T`, however, it is possible to cast from `T` to - //! > bool and then to `T` again; the result will be `0` or `1` depending - //! > on the truth value. If you want to use a pointer type or something - //! > similar in a conditional, it is suggested to explicitly convert it - //! > to bool by using `to<bool>`. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Boolean_algebra_(structure) - template <typename L> - struct Logical; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/metafunction.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/metafunction.hpp deleted file mode 100644 index 72884911f3..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/metafunction.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Metafunction`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP -#define BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Metafunction Metafunction - //! A `Metafunction` is a function that takes `hana::type`s as inputs and - //! returns a `hana::type` as output. - //! - //! A `Metafunction` is an object satisfying the [FunctionObject][1] - //! concept, but with additional requirements. First, it must be possible - //! to apply a `Metafunction` to arguments whose tag is `type_tag`, and - //! the result of such an application must be an object whose tag is also - //! `type_tag`. Note that `hana::type` and `hana::basic_type` are the - //! only such types. - //! - //! Secondly, a `Metafunction` must provide a nested `::%apply` template - //! which allows performing the same type-level computation as is done by - //! the call operator. In Boost.MPL parlance, a `Metafunction` `F` is - //! hence a [MetafunctionClass][2] in addition to being a `FunctionObject`. - //! Rigorously, the following must be satisfied by any object `f` of type - //! `F` which is a `Metafunction`, and for arbitrary types `T...`: - //! @code - //! f(hana::type_c<T>...) == hana::type_c<F::apply<T...>::type> - //! @endcode - //! - //! Thirdly, to ease the inter-operation of values and types, - //! `Metafunction`s must also allow being called with arguments that - //! are not `hana::type`s. In that case, the result is equivalent to - //! calling the metafunction on the types of the arguments. Rigorously, - //! this means that for arbitrary objects `x...`, - //! @code - //! f(x...) == f(hana::type_c<decltype(x)>...) - //! @endcode - //! - //! - //! Minimal complete definition - //! --------------------------- - //! The `Metafunction` concept does not have a minimal complete definition - //! in terms of tag-dispatched methods. Instead, the syntactic requirements - //! documented above should be satisfied, and the `Metafunction` struct - //! should be specialized explicitly in Hana's namespace. - //! - //! - //! Concrete models - //! --------------- - //! `hana::metafunction`, `hana::metafunction_class`, `hana::template_` - //! - //! - //! Rationale: Why aren't `Metafunction`s `Comparable`? - //! --------------------------------------------------- - //! When seeing `hana::template_`, a question that naturally arises is - //! whether `Metafunction`s should be made `Comparable`. Indeed, it - //! would seem to make sense to compare two templates `F` and `G` with - //! `template_<F> == template_<G>`. However, in the case where `F` and/or - //! `G` are alias templates, it makes sense to talk about two types of - //! comparisons. The first one is _shallow_ comparison, and it determines - //! that two alias templates are equal if they are the same alias - //! template. The second one is _deep_ comparison, and it determines - //! that two template aliases are equal if they alias the same type for - //! any template argument. For example, given `F` and `G` defined as - //! @code - //! template <typename T> - //! using F = void; - //! - //! template <typename T> - //! using G = void; - //! @endcode - //! - //! shallow comparison would determine that `F` and `G` are different - //! because they are two different template aliases, while deep comparison - //! would determine that `F` and `G` are equal because they always - //! expand to the same type, `void`. Unfortunately, deep comparison is - //! impossible to implement because one would have to check `F` and `G` - //! on all possible types. On the other hand, shallow comparison is not - //! satisfactory because `Metafunction`s are nothing but functions on - //! `type`s, and the equality of two functions is normally defined with - //! deep comparison. Hence, we adopt a conservative stance and avoid - //! providing comparison for `Metafunction`s. - //! - //! [1]: http://en.cppreference.com/w/cpp/concept/FunctionObject - //! [2]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/metafunction-class.html - template <typename F> - struct Metafunction; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/monad.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/monad.hpp deleted file mode 100644 index b310868e44..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/monad.hpp +++ /dev/null @@ -1,198 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Monad`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_MONAD_HPP -#define BOOST_HANA_FWD_CONCEPT_MONAD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Monad Monad - //! The `Monad` concept represents `Applicative`s with the ability to - //! flatten nested levels of structure. - //! - //! Historically, Monads are a construction coming from category theory, - //! an abstract branch of mathematics. The functional programming - //! community eventually discovered how Monads could be used to - //! formalize several useful things like side effects, which led - //! to the wide adoption of Monads in that community. However, even - //! in a multi-paradigm language like C++, there are several constructs - //! which turn out to be Monads, like `std::optional`, `std::vector` and - //! others. - //! - //! Everybody tries to introduce `Monad`s with a different analogy, and - //! most people fail. This is called the [Monad tutorial fallacy][1]. We - //! will try to avoid this trap by not presenting a specific intuition, - //! and we will instead present what monads are mathematically. - //! For specific intuitions, we will let readers who are new to this - //! concept read one of the many excellent tutorials available online. - //! Understanding Monads might take time at first, but once you get it, - //! a lot of patterns will become obvious Monads; this enlightening will - //! be your reward for the hard work. - //! - //! There are different ways of defining a Monad; Haskell uses a function - //! called `bind` (`>>=`) and another one called `return` (it has nothing - //! to do with C++'s `return` statement). They then introduce relationships - //! that must be satisfied for a type to be a Monad with those functions. - //! Mathematicians sometimes use a function called `join` and another one - //! called `unit`, or they also sometimes use other category theoretic - //! constructions like functor adjunctions and the Kleisli category. - //! - //! This library uses a composite approach. First, we use the `flatten` - //! function (equivalent to `join`) along with the `lift` function from - //! `Applicative` (equivalent to `unit`) to introduce the notion of - //! monadic function composition. We then write the properties that must - //! be satisfied by a Monad using this monadic composition operator, - //! because we feel it shows the link between Monads and Monoids more - //! clearly than other approaches. - //! - //! Roughly speaking, we will say that a `Monad` is an `Applicative` which - //! also defines a way to compose functions returning a monadic result, - //! as opposed to only being able to compose functions returning a normal - //! result. We will then ask for this composition to be associative and to - //! have a neutral element, just like normal function composition. For - //! usual composition, the neutral element is the identity function `id`. - //! For monadic composition, the neutral element is the `lift` function - //! defined by `Applicative`. This construction is made clearer in the - //! laws below. - //! - //! @note - //! Monads are known to be a big chunk to swallow. However, it is out of - //! the scope of this documentation to provide a full-blown explanation - //! of the concept. The [Typeclassopedia][2] is a nice Haskell-oriented - //! resource where more information about Monads can be found. - //! - //! - //! Minimal complete definitions - //! ---------------------------- - //! First, a `Monad` must be both a `Functor` and an `Applicative`. - //! Also, an implementation of `flatten` or `chain` satisfying the - //! laws below for monadic composition must be provided. - //! - //! @note - //! The `ap` method for `Applicatives` may be derived from the minimal - //! complete definition of `Monad` and `Functor`; see below for more - //! information. - //! - //! - //! Laws - //! ---- - //! To simplify writing the laws, we use the comparison between functions. - //! For two functions `f` and `g`, we define - //! @code - //! f == g if and only if f(x) == g(x) for all x - //! @endcode - //! - //! With the usual composition of functions, we are given two functions - //! @f$ f : A \to B @f$ and @f$ g : B \to C @f$, and we must produce a - //! new function @f$ compose(g, f) : A \to C @f$. This composition of - //! functions is associative, which means that - //! @code - //! compose(h, compose(g, f)) == compose(compose(h, g), f) - //! @endcode - //! - //! Also, this composition has an identity element, which is the identity - //! function. This simply means that - //! @code - //! compose(f, id) == compose(id, f) == f - //! @endcode - //! - //! This is probably nothing new if you are reading the `Monad` laws. - //! Now, we can observe that the above is equivalent to saying that - //! functions with the composition operator form a `Monoid`, where the - //! neutral element is the identity function. - //! - //! Given an `Applicative` `F`, what if we wanted to compose two functions - //! @f$ f : A \to F(B) @f$ and @f$ g : B \to F(C) @f$? When the - //! `Applicative` `F` is also a `Monad`, such functions taking normal - //! values but returning monadic values are called _monadic functions_. - //! To compose them, we obviously can't use normal function composition, - //! since the domains and codomains of `f` and `g` do not match properly. - //! Instead, we'll need a new operator -- let's call it `monadic_compose`: - //! @f[ - //! \mathtt{monadic\_compose} : - //! (B \to F(C)) \times (A \to F(B)) \to (A \to F(C)) - //! @f] - //! - //! How could we go about implementing this function? Well, since we know - //! `F` is an `Applicative`, the only functions we have are `transform` - //! (from `Functor`), and `lift` and `ap` (from `Applicative`). Hence, - //! the only thing we can do at this point while respecting the signatures - //! of `f` and `g` is to set (for `x` of type `A`) - //! @code - //! monadic_compose(g, f)(x) = transform(f(x), g) - //! @endcode - //! - //! Indeed, `f(x)` is of type `F(B)`, so we can map `g` (which takes `B`'s) - //! on it. Doing so will leave us with a result of type `F(F(C))`, but what - //! we wanted was a result of type `F(C)` to respect the signature of - //! `monadic_compose`. If we had a joker of type @f$ F(F(C)) \to F(C) @f$, - //! we could simply set - //! @code - //! monadic_compose(g, f)(x) = joker(transform(f(x), g)) - //! @endcode - //! - //! and we would be happy. It turns out that `flatten` is precisely this - //! joker. Now, we'll want our joker to satisfy some properties to make - //! sure this composition is associative, just like our normal composition - //! was. These properties are slightly cumbersome to specify, so we won't - //! do it here. Also, we'll need some kind of neutral element for the - //! composition. This neutral element can't be the usual identity function, - //! because it does not have the right type: our neutral element needs to - //! be a function of type @f$ X \to F(X) @f$ but the identity function has - //! type @f$ X \to X @f$. It is now the right time to observe that `lift` - //! from `Applicative` has exactly the right signature, and so we'll take - //! this for our neutral element. - //! - //! We are now ready to formulate the `Monad` laws using this composition - //! operator. For a `Monad` `M` and functions @f$ f : A \to M(B) @f$, - //! @f$ g : B \to M(C) @f$ and @f$ h : C \to M(D) @f$, the following - //! must be satisfied: - //! @code - //! // associativity - //! monadic_compose(h, monadic_compose(g, f)) == monadic_compose(monadic_compose(h, g), f) - //! - //! // right identity - //! monadic_compose(f, lift<M(A)>) == f - //! - //! // left identity - //! monadic_compose(lift<M(B)>, f) == f - //! @endcode - //! - //! which is to say that `M` along with monadic composition is a Monoid - //! where the neutral element is `lift`. - //! - //! - //! Refined concepts - //! ---------------- - //! 1. `Functor` - //! 2. `Applicative` (free implementation of `ap`)\n - //! When the minimal complete definition for `Monad` and `Functor` are - //! both satisfied, it is possible to implement `ap` by setting - //! @code - //! ap(fs, xs) = chain(fs, [](auto f) { - //! return transform(xs, f); - //! }) - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::lazy`, `hana::optional`, `hana::tuple` - //! - //! - //! [1]: https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/ - //! [2]: https://wiki.haskell.org/Typeclassopedia#Monad - template <typename M> - struct Monad; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_MONAD_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/monad_plus.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/monad_plus.hpp deleted file mode 100644 index dcdf65e210..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/monad_plus.hpp +++ /dev/null @@ -1,89 +0,0 @@ -/*! -@file -Forward declares `boost::hana::MonadPlus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP -#define BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-MonadPlus MonadPlus - //! The `MonadPlus` concept represents Monads with a monoidal structure. - //! - //! Intuitively, whereas a Monad can be seen as some kind of container - //! or context, a MonadPlus can be seen as a container or a context that - //! can be concatenated with other containers or contexts. There must - //! also be an identity element for this combining operation. For example, - //! a tuple is a MonadPlus, because tuples can be concatenated and the - //! empty tuple would act as an identity for concatenation. How is this - //! different from a Monad which is also a Monoid? The answer is that the - //! monoidal structure on a MonadPlus must _not_ depend of the contents - //! of the structure; it must not require the contents to be a Monoid - //! in order to work. - //! - //! While sequences are not the only possible model for MonadPlus, the - //! method names used here refer to the MonadPlus of sequences under - //! concatenation. Several useful functions generalizing operations on - //! sequences are included with this concept, like `append`, `prepend` - //! and `filter`. - //! - //! @note - //! This documentation does not go into much details about the nature - //! of the MonadPlus concept. However, there is a nice Haskell-oriented - //! [WikiBook][1] going into further details. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `concat` and `empty` - //! - //! - //! Laws - //! ---- - //! First, a MonadPlus is required to have a monoidal structure. Hence, it - //! is no surprise that for any MonadPlus `M`, we require `M(T)` to be a - //! valid monoid. However, we do not enforce that `M(T)` actually models - //! the Monoid concept provided by Hana. Further, for all objects `a, b, c` - //! of data type `M(T)`, - //! @code - //! // identity - //! concat(empty<M(T)>(), a) == a - //! concat(a, empty<M(T)>()) == a - //! - //! // associativity - //! concat(a, concat(b, c)) == concat(concat(a, b), c) - //! @endcode - //! - //! Secondly, a MonadPlus is also required to obey the following laws, - //! which represent the fact that `empty<M(T)>()` must be some kind of - //! absorbing element for the `chain` operation. For all objects `a` of - //! data type `M(T)` and functions @f$ f : T \to M(U) @f$, - //! @code - //! chain(empty<M(T)>(), f) == empty<M(U)>() - //! chain(a, always(empty<M(T)>())) == empty<M(U)>() - //! @endcode - //! - //! - //! Refined concepts - //! ---------------- - //! `Functor`, `Applicative` and `Monad` - //! - //! - //! Concrete models - //! --------------- - //! `hana::optional`, `hana::tuple` - //! - //! [1]: https://en.wikibooks.org/wiki/Haskell/MonadPlus - template <typename M> - struct MonadPlus; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/monoid.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/monoid.hpp deleted file mode 100644 index 381e29dff7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/monoid.hpp +++ /dev/null @@ -1,101 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Monoid`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_MONOID_HPP -#define BOOST_HANA_FWD_CONCEPT_MONOID_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Monoid Monoid - //! The `Monoid` concept represents data types with an associative - //! binary operation that has an identity. - //! - //! Specifically, a [Monoid][1] is a basic algebraic structure typically - //! used in mathematics to construct more complex algebraic structures - //! like `Group`s, `Ring`s and so on. They are useful in several contexts, - //! notably to define the properties of numbers in a granular way. At its - //! core, a `Monoid` is a set `S` of objects along with a binary operation - //! (let's say `+`) that is associative and that has an identity in `S`. - //! There are many examples of `Monoid`s: - //! - strings with concatenation and the empty string as the identity - //! - integers with addition and `0` as the identity - //! - integers with multiplication and `1` as the identity - //! - many others... - //! - //! As you can see with the integers, there are some sets that can be - //! viewed as a monoid in more than one way, depending on the choice - //! of the binary operation and identity. The method names used here - //! refer to the monoid of integers under addition; `plus` is the binary - //! operation and `zero` is the identity element of that operation. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `plus` and `zero` satisfying the laws - //! - //! - //! Laws - //! ---- - //! For all objects `x`, `y` and `z` of a `Monoid` `M`, the following - //! laws must be satisfied: - //! @code - //! plus(zero<M>(), x) == x // left zero - //! plus(x, zero<M>()) == x // right zero - //! plus(x, plus(y, z)) == plus(plus(x, y), z) // associativity - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Free model for non-boolean arithmetic data types - //! ------------------------------------------------ - //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is - //! true. For a non-boolean arithmetic data type `T`, a model of `Monoid` - //! is automatically defined by setting - //! @code - //! plus(x, y) = (x + y) - //! zero<T>() = static_cast<T>(0) - //! @endcode - //! - //! > #### Rationale for not making `bool` a `Monoid` by default - //! > First, it makes no sense whatsoever to define an additive `Monoid` - //! > over the `bool` type. Also, it could make sense to define a `Monoid` - //! > with logical conjunction or disjunction. However, C++ allows `bool`s - //! > to be added, and the method names of this concept really suggest - //! > addition. In line with the principle of least surprise, no model - //! > is provided by default. - //! - //! - //! Structure-preserving functions - //! ------------------------------ - //! Let `A` and `B` be two `Monoid`s. A function `f : A -> B` is said - //! to be a [Monoid morphism][2] if it preserves the monoidal structure - //! between `A` and `B`. Rigorously, for all objects `x, y` of data - //! type `A`, - //! @code - //! f(plus(x, y)) == plus(f(x), f(y)) - //! f(zero<A>()) == zero<B>() - //! @endcode - //! Functions with these properties interact nicely with `Monoid`s, which - //! is why they are given such a special treatment. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Monoid - //! [2]: http://en.wikipedia.org/wiki/Monoid#Monoid_homomorphisms - template <typename M> - struct Monoid; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_MONOID_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/orderable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/orderable.hpp deleted file mode 100644 index 7c4cf233db..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/orderable.hpp +++ /dev/null @@ -1,187 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Orderable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Orderable Orderable - //! The `Orderable` concept represents totally ordered data types. - //! - //! Intuitively, `Orderable` objects must define a binary predicate named - //! `less` returning whether the first argument is to be considered less - //! than the second argument. The word "total" means that _distinct_ - //! objects must always be ordered; if `a` and `b` are not equal, then - //! exactly one of `less(a, b)` and `less(b, a)` must be true. This is - //! a contrast with weaker kinds of orders that would allow some objects - //! to be incomparable (neither less than nor greater than). Also note - //! that a non-strict total order may always be obtained from a strict - //! total order (and vice-versa) by setting - //! @code - //! a <= b = !(b < a) - //! a < b = !(b <= a) - //! @endcode - //! The non-strict version is used in the description of the laws because - //! it makes them easier to parse for humans, but they could be formulated - //! equivalently using the strict order. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `less` - //! - //! When `less` is defined, the other methods are defined from it using - //! the same definition as mandated in the laws below. - //! - //! - //! Laws - //! ---- - //! Rigorously speaking, a [total order][1] `<=` on a set `S` is a binary - //! predicate @f$ <= \;: S \times S \to bool @f$ such that for all - //! `a`, `b`, `c` in `S`, - //! @code - //! if a <= b and b <= a then a == b // Antisymmetry - //! if a <= b and b <= c then a <= c // Transitivity - //! either a <= b or b <= a // Totality - //! @endcode - //! Additionally, the `less`, `greater` and `greater_equal` methods should - //! have the following intuitive meanings: - //! @code - //! a < b if and only if !(b <= a) - //! a > b if and only if b < a - //! a >= b if and only if !(a < b) - //! @endcode - //! - //! - //! Refined concept - //! --------------- - //! 1. `Comparable` (free model)\n - //! Since `Orderable` requires `less_equal` to be a total order, a model - //! of `Comparable` may always be obtained by setting - //! @code - //! equal(x, y) = less_equal(x, y) && less_equal(y, x) - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant`, `hana::optional`, `hana::pair`, - //! `hana::string`, `hana::tuple` - //! - //! - //! Free model for `LessThanComparable` data types - //! ---------------------------------------------- - //! Two data types `T` and `U` that model the cross-type version of the - //! usual [LessThanComparable][2] C++ concept are automatically a model - //! of `Orderable` by setting - //! @code - //! less(x, y) = (x < y) - //! @endcode - //! The cross-type version of the LessThanComparable concept is analogous - //! to the cross-type version of the EqualityComparable concept presented - //! in [N3351][3], which is compatible with the usual single type - //! definition. - //! However, note that the LessThanComparable concept only requires `<` - //! to be a [strict weak ordering][4], which is a weaker requirement - //! than being a total order. Hence, if `less` is used with objects - //! of a LessThanComparable data type that do not define a total order, - //! some algorithms may have an unexpected behavior. It is the author's - //! opinion that defining `operator<` as a non-total order is a bad idea, - //! but this is debatable and so the design choice of providing a model - //! for LessThanComparable data types is open to debate. Waiting for - //! some user input. - //! - //! - //! Order-preserving functions - //! -------------------------- - //! Let `A` and `B` be two `Orderable` data types. A function - //! @f$ f : A \to B@f$ is said to be order-preserving (also called - //! monotone) if it preserves the structure of the `Orderable` concept, - //! which can be rigorously stated as follows. For all objects `x`, `y` - //! of data type `A`, - //! @code - //! if less(x, y) then less(f(x), f(y)) - //! @endcode - //! Another important property is that of being order-reflecting, which - //! can be stated as - //! @code - //! if less(f(x), f(y)) then less(x, y) - //! @endcode - //! We say that a function is an order-embedding if it is both - //! order-preserving and order-reflecting, i.e. if - //! @code - //! less(x, y) if and only if less(f(x), f(y)) - //! @endcode - //! - //! - //! Cross-type version of the methods - //! --------------------------------- - //! The comparison methods (`less`, `less_equal`, `greater` and - //! `greater_equal`) are "overloaded" to handle distinct data types - //! with certain properties. Specifically, they are defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `Orderable` when taken individually - //! 3. @f$\mathrm{to<C>} : A \to C@f$ and @f$\mathrm{to<C>} : B \to C@f$ - //! are both order-embeddings as determined by the `is_embedding` - //! metafunction. - //! - //! The method definitions for data types satisfying the above - //! properties are - //! @code - //! less(x, y) = less(to<C>(x), to<C>(y)) - //! less_equal(x, y) = less_equal(to<C>(x), to<C>(y)) - //! greater_equal(x, y) = greater_equal(to<C>(x), to<C>(y)) - //! greater(x, y) = greater(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Partial application of the methods - //! ---------------------------------- - //! The `less`, `greater`, `less_equal` and `greater_equal` methods can - //! be called in two different ways. First, they can be called like - //! normal functions: - //! @code - //! less(x, y) - //! greater(x, y) - //! - //! less_equal(x, y) - //! greater_equal(x, y) - //! @endcode - //! - //! However, they may also be partially applied to an argument as follows: - //! @code - //! less.than(x)(y) == less(y, x) - //! greater.than(x)(y) == greater(y, x) - //! - //! less_equal.than(x)(y) == less_equal(y, x) - //! greater_equal.than(x)(y) == greater_equal(y, x) - //! @endcode - //! - //! Take good note that the order of the arguments is reversed, so - //! for example `less.than(x)(y)` is equivalent to `less(y, x)`, not - //! `less(x, y)`. This is because those variants are meant to be used - //! with higher order algorithms, where the chosen application order - //! makes sense. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Total_order - //! [2]: http://en.cppreference.com/w/cpp/concept/LessThanComparable - //! [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf - //! [4]: http://en.wikipedia.org/wiki/Strict_weak_ordering - template <typename Ord> - struct Orderable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/product.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/product.hpp deleted file mode 100644 index 0d029fdb11..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/product.hpp +++ /dev/null @@ -1,103 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP -#define BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Product Product - //! Represents types that are generic containers of two elements. - //! - //! This concept basically represents types that are like `std::pair`. - //! The motivation for making such a precise concept is similar to the - //! motivation behind the `Sequence` concept; there are many different - //! implementations of `std::pair` in different libraries, and we would - //! like to manipulate any of them generically. - //! - //! Since a `Product` is basically a pair, it is unsurprising that the - //! operations provided by this concept are getting the first and second - //! element of a pair, creating a pair from two elements and other - //! simmilar operations. - //! - //! @note - //! Mathematically, this concept represents types that are category - //! theoretical [products][1]. This is also where the name comes - //! from. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `first`, `second` and `make` - //! - //! `first` and `second` must obviously return the first and the second - //! element of the pair, respectively. `make` must take two arguments `x` - //! and `y` representing the first and the second element of the pair, - //! and return a pair `p` such that `first(p) == x` and `second(p) == y`. - //! @include example/product/make.cpp - //! - //! - //! Laws - //! ---- - //! For a model `P` of `Product`, the following laws must be satisfied. - //! For every data types `X` and `Y`, there must be a unique function - //! @f$ \mathtt{make} : X \times Y \to P @f$ such that for every `x`, `y`, - //! @code - //! x == first(make<P>(x, y)) - //! y == second(make<P>(x, y)) - //! @endcode - //! - //! @note - //! This law is less general than the universal property typically used to - //! define category theoretical products, but it is vastly enough for what - //! we need. - //! - //! This is basically saying that a `Product` must be the most general - //! object able to contain a pair of objects `(P1, P2)`, but nothing - //! more. Since the categorical product is defined by a universal - //! property, all the models of this concept are isomorphic, and - //! the isomorphism is unique. In other words, there is one and only - //! one way to convert one `Product` to another. - //! - //! Another property that must be satisfied by `first` and `second` is - //! that of @ref move-independence, which ensures that we can optimally - //! decompose a `Product` into its two members without making redundant - //! copies. - //! - //! - //! Refined concepts - //! ---------------- - //! 1. `Comparable` (free model)\n - //! Two products `x` and `y` are equal iff they are equal element-wise, - //! by comparing the first element before the second element. - //! @include example/product/comparable.cpp - //! - //! 2. `Orderable` (free model)\n - //! Products are ordered using a lexicographical ordering as-if they - //! were 2-element tuples. - //! - //! 3. `Foldable` (free model)\n - //! Folding a `Product` `p` is equivalent to folding a list containing - //! `first(p)` and `second(p)`, in that order. - //! - //! - //! Concrete models - //! --------------- - //! `hana::pair` - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Product_(category_theory) - template <typename P> - struct Product; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/ring.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/ring.hpp deleted file mode 100644 index 45b301f272..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/ring.hpp +++ /dev/null @@ -1,106 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Ring`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_RING_HPP -#define BOOST_HANA_FWD_CONCEPT_RING_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Ring Ring - //! The `Ring` concept represents `Group`s that also form a `Monoid` - //! under a second binary operation that distributes over the first. - //! - //! A [Ring][1] is an algebraic structure built on top of a `Group` - //! which requires a monoidal structure with respect to a second binary - //! operation. This second binary operation must distribute over the - //! first one. Specifically, a `Ring` is a triple `(S, +, *)` such that - //! `(S, +)` is a `Group`, `(S, *)` is a `Monoid` and `*` distributes - //! over `+`, i.e. - //! @code - //! x * (y + z) == (x * y) + (x * z) - //! @endcode - //! - //! The second binary operation is often written `*` with its identity - //! written `1`, in reference to the `Ring` of integers under - //! multiplication. The method names used here refer to this exact ring. - //! - //! - //! Minimal complete definintion - //! ---------------------------- - //! `one` and `mult` satisfying the laws - //! - //! - //! Laws - //! ---- - //! For all objects `x`, `y`, `z` of a `Ring` `R`, the following laws must - //! be satisfied: - //! @code - //! mult(x, mult(y, z)) == mult(mult(x, y), z) // associativity - //! mult(x, one<R>()) == x // right identity - //! mult(one<R>(), x) == x // left identity - //! mult(x, plus(y, z)) == plus(mult(x, y), mult(x, z)) // distributivity - //! @endcode - //! - //! - //! Refined concepts - //! ---------------- - //! `Monoid`, `Group` - //! - //! - //! Concrete models - //! --------------- - //! `hana::integral_constant` - //! - //! - //! Free model for non-boolean arithmetic data types - //! ------------------------------------------------ - //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is - //! true. For a non-boolean arithmetic data type `T`, a model of `Ring` is - //! automatically defined by using the provided `Group` model and setting - //! @code - //! mult(x, y) = (x * y) - //! one<T>() = static_cast<T>(1) - //! @endcode - //! - //! @note - //! The rationale for not providing a Ring model for `bool` is the same - //! as for not providing Monoid and Group models. - //! - //! - //! Structure-preserving functions - //! ------------------------------ - //! Let `A` and `B` be two `Ring`s. A function `f : A -> B` is said to - //! be a [Ring morphism][2] if it preserves the ring structure between - //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, - //! @code - //! f(plus(x, y)) == plus(f(x), f(y)) - //! f(mult(x, y)) == mult(f(x), f(y)) - //! f(one<A>()) == one<B>() - //! @endcode - //! Because of the `Ring` structure, it is easy to prove that the - //! following will then also be satisfied: - //! @code - //! f(zero<A>()) == zero<B>() - //! f(negate(x)) == negate(f(x)) - //! @endcode - //! which is to say that `f` will then also be a `Group` morphism. - //! Functions with these properties interact nicely with `Ring`s, - //! which is why they are given such a special treatment. - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Ring_(mathematics) - //! [2]: http://en.wikipedia.org/wiki/Ring_homomorphism - template <typename R> - struct Ring; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_RING_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/searchable.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/searchable.hpp deleted file mode 100644 index 2c1e22fc4a..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/searchable.hpp +++ /dev/null @@ -1,143 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Searchable`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP -#define BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Searchable Searchable - //! The `Searchable` concept represents structures that can be searched. - //! - //! Intuitively, a `Searchable` is any structure, finite or infinite, - //! containing elements that can be searched using a predicate. Sometimes, - //! `Searchable`s will associate keys to values; one can search for a key - //! with a predicate, and the value associated to it is returned. This - //! gives rise to map-like data structures. Other times, the elements of - //! the structure that are searched (i.e. those to which the predicate is - //! applied) are the same that are returned, which gives rise to set-like - //! data structures. In general, we will refer to the _keys_ of a - //! `Searchable` structure as those elements that are used for searching, - //! and to the _values_ of a `Searchable` as those elements that are - //! returned when a search is successful. As was explained, there is no - //! requirement that both notions differ, and it is often useful to have - //! keys and values coincide (think about `std::set`). - //! - //! Some methods like `any_of`, `all_of` and `none_of` allow simple queries - //! to be performed on the keys of the structure, while other methods like - //! `find` and `find_if` make it possible to find the value associated - //! to a key. The most specific method should always be used if one - //! cares about performance, because it is usually the case that heavy - //! optimizations can be performed in more specific methods. For example, - //! an associative data structure implemented as a hash table will be much - //! faster to access using `find` than `find_if`, because in the second - //! case it will have to do a linear search through all the entries. - //! Similarly, using `contains` will likely be much faster than `any_of` - //! with an equivalent predicate. - //! - //! > __Insight__\n - //! > In a lazy evaluation context, any `Foldable` can also become a model - //! > of `Searchable` because we can search lazily through the structure - //! > with `fold_right`. However, in the context of C++, some `Searchable`s - //! > can not be folded; think for example of an infinite set. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `find_if` and `any_of` - //! - //! When `find_if` and `any_of` are provided, the other functions are - //! implemented according to the laws explained below. - //! - //! @note - //! We could implement `any_of(xs, pred)` by checking whether - //! `find_if(xs, pred)` is an empty `optional` or not, and then reduce - //! the minimal complete definition to `find_if`. However, this is not - //! done because that implementation requires the predicate of `any_of` - //! to return a compile-time `Logical`, which is more restrictive than - //! what we have right now. - //! - //! - //! Laws - //! ---- - //! In order for the semantics of the methods to be consistent, some - //! properties must be satisfied by any model of the `Searchable` concept. - //! Rigorously, for any `Searchable`s `xs` and `ys` and any predicate `p`, - //! the following laws should be satisfied: - //! @code - //! any_of(xs, p) <=> !all_of(xs, negated p) - //! <=> !none_of(xs, p) - //! - //! contains(xs, x) <=> any_of(xs, equal.to(x)) - //! - //! find(xs, x) == find_if(xs, equal.to(x)) - //! find_if(xs, always(false_)) == nothing - //! - //! is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); }) - //! is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); }) - //! @endcode - //! - //! Additionally, if all the keys of the `Searchable` are `Logical`s, - //! the following laws should be satisfied: - //! @code - //! any(xs) <=> any_of(xs, id) - //! all(xs) <=> all_of(xs, id) - //! none(xs) <=> none_of(xs, id) - //! @endcode - //! - //! - //! Concrete models - //! --------------- - //! `hana::map`, `hana::optional`, `hana::range`, `hana::set`, - //! `hana::string`, `hana::tuple` - //! - //! - //! Free model for builtin arrays - //! ----------------------------- - //! Builtin arrays whose size is known can be searched as-if they were - //! homogeneous tuples. However, since arrays can only hold objects of - //! a single type and the predicate to `find_if` must return a compile-time - //! `Logical`, the `find_if` method is fairly useless. For similar reasons, - //! the `find` method is also fairly useless. This model is provided mainly - //! because of the `any_of` method & friends, which are both useful and - //! compile-time efficient. - //! - //! - //! Structure preserving functions - //! ------------------------------ - //! Given two `Searchables` `S1` and `S2`, a function - //! @f$ f : S_1(X) \to S_2(X) @f$ is said to preserve the `Searchable` - //! structure if for all `xs` of data type `S1(X)` and predicates - //! @f$ \mathtt{pred} : X \to Bool @f$ (for a `Logical` `Bool`), - //! @code - //! any_of(xs, pred) if and only if any_of(f(xs), pred) - //! find_if(xs, pred) == find_if(f(xs), pred) - //! @endcode - //! - //! This is really just a generalization of the following, more intuitive - //! requirements. For all `xs` of data type `S1(X)` and `x` of data type - //! `X`, - //! @code - //! x ^in^ xs if and only if x ^in^ f(xs) - //! find(xs, x) == find(f(xs), x) - //! @endcode - //! - //! These requirements can be understood as saying that `f` does not - //! change the content of `xs`, although it may reorder elements. - //! As usual, such a structure-preserving transformation is said to - //! be an embedding if it is also injective, i.e. if it is a lossless - //! transformation. - template <typename S> - struct Searchable; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/sequence.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/sequence.hpp deleted file mode 100644 index 84cedd1263..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/sequence.hpp +++ /dev/null @@ -1,165 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Sequence`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP -#define BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Sequence Sequence - //! The `Sequence` concept represents generic index-based sequences. - //! - //! Compared to other abstract concepts, the Sequence concept is very - //! specific. It represents generic index-based sequences. The reason - //! why such a specific concept is provided is because there are a lot - //! of models that behave exactly the same while being implemented in - //! wildly different ways. It is useful to regroup all those data types - //! under the same umbrella for the purpose of generic programming. - //! - //! In fact, models of this concept are not only _similar_. They are - //! actually _isomorphic_, in a sense that we define below, which is - //! a fancy way of rigorously saying that they behave exactly the same - //! to an external observer. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `Iterable`, `Foldable`, and `make` - //! - //! The `Sequence` concept does not provide basic methods that could be - //! used as a minimal complete definition; instead, it borrows methods - //! from other concepts and add laws to them. For this reason, it is - //! necessary to specialize the `Sequence` metafunction in Hana's - //! namespace to tell Hana that a type is indeed a `Sequence`. Explicitly - //! specializing the `Sequence` metafunction can be seen like a seal - //! saying "this data type satisfies the additional laws of a `Sequence`", - //! since those can't be checked by Hana automatically. - //! - //! - //! Laws - //! ---- - //! The laws for being a `Sequence` are simple, and their goal is to - //! restrict the semantics that can be associated to the functions - //! provided by other concepts. First, a `Sequence` must be a finite - //! `Iterable` (thus a `Foldable` too). Secondly, for a `Sequence` tag - //! `S`, `make<S>(x1, ..., xn)` must be an object of tag `S` and whose - //! linearization is `[x1, ..., xn]`. This basically ensures that objects - //! of tag `S` are equivalent to their linearization, and that they can - //! be created from such a linearization (with `make`). - //! - //! While it would be possible in theory to handle infinite sequences, - //! doing so complicates the implementation of many algorithms. For - //! simplicity, the current version of the library only handles finite - //! sequences. However, note that this does not affect in any way the - //! potential for having infinite `Searchable`s and `Iterable`s. - //! - //! - //! Refined concepts - //! ---------------- - //! 1. `Comparable` (definition provided automatically)\n - //! Two `Sequence`s are equal if and only if they contain the same number - //! of elements and their elements at any given index are equal. - //! @include example/sequence/comparable.cpp - //! - //! 2. `Orderable` (definition provided automatically)\n - //! `Sequence`s are ordered using the traditional lexicographical ordering. - //! @include example/sequence/orderable.cpp - //! - //! 3. `Functor` (definition provided automatically)\n - //! `Sequence`s implement `transform` as the mapping of a function over - //! each element of the sequence. This is somewhat equivalent to what - //! `std::transform` does to ranges of iterators. Also note that mapping - //! a function over an empty sequence returns an empty sequence and never - //! applies the function, as would be expected. - //! @include example/sequence/functor.cpp - //! - //! 4. `Applicative` (definition provided automatically)\n - //! First, `lift`ing a value into a `Sequence` is the same as creating a - //! singleton sequence containing that value. Second, applying a sequence - //! of functions to a sequence of values will apply each function to - //! all the values in the sequence, and then return a list of all the - //! results. In other words, - //! @code - //! ap([f1, ..., fN], [x1, ..., xM]) == [ - //! f1(x1), ..., f1(xM), - //! ... - //! fN(x1), ..., fN(xM) - //! ] - //! @endcode - //! Example: - //! @include example/sequence/applicative.cpp - //! - //! 5. `Monad` (definition provided automatically)\n - //! First, `flaten`ning a `Sequence` takes a sequence of sequences and - //! concatenates them to get a larger sequence. In other words, - //! @code - //! flatten([[a1, ..., aN], ..., [z1, ..., zM]]) == [ - //! a1, ..., aN, ..., z1, ..., zM - //! ] - //! @endcode - //! This acts like a `std::tuple_cat` function, except it receives a - //! sequence of sequences instead of a variadic pack of sequences to - //! flatten.\n - //! __Example__: - //! @include example/sequence/monad.ints.cpp - //! Also note that the model of `Monad` for `Sequence`s can be seen as - //! modeling nondeterminism. A nondeterministic computation can be - //! modeled as a function which returns a sequence of possible results. - //! In this line of thought, `chain`ing a sequence of values into such - //! a function will return a sequence of all the possible output values, - //! i.e. a sequence of all the values applied to all the functions in - //! the sequences.\n - //! __Example__: - //! @include example/sequence/monad.types.cpp - //! - //! 6. `MonadPlus` (definition provided automatically)\n - //! `Sequence`s are models of the `MonadPlus` concept by considering the - //! empty sequence as the unit of `concat`, and sequence concatenation - //! as `concat`. - //! @include example/sequence/monad_plus.cpp - //! - //! 7. `Foldable`\n - //! The model of `Foldable` for `Sequence`s is uniquely determined by the - //! model of `Iterable`. - //! @include example/sequence/foldable.cpp - //! - //! 8. `Iterable`\n - //! The model of `Iterable` for `Sequence`s corresponds to iteration over - //! each element of the sequence, in order. This model is not provided - //! automatically, and it is in fact part of the minimal complete - //! definition for the `Sequence` concept. - //! @include example/sequence/iterable.cpp - //! - //! 9. `Searchable` (definition provided automatically)\n - //! Searching through a `Sequence` is equivalent to just searching through - //! a list of the values it contains. The keys and the values on which - //! the search is performed are both the elements of the sequence. - //! @include example/sequence/searchable.cpp - //! - //! - //! Concrete models - //! --------------- - //! `hana::tuple` - //! - //! - //! [1]: http://en.wikipedia.org/wiki/Isomorphism#Isomorphism_vs._bijective_morphism -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename S> - struct Sequence; -#else - template <typename S, typename = void> - struct Sequence : Sequence<S, when<true>> { }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/concept/struct.hpp b/contrib/restricted/boost/boost/hana/fwd/concept/struct.hpp deleted file mode 100644 index d9d0cffb58..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/concept/struct.hpp +++ /dev/null @@ -1,156 +0,0 @@ -/*! -@file -Forward declares `boost::hana::Struct`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONCEPT_STRUCT_HPP -#define BOOST_HANA_FWD_CONCEPT_STRUCT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-concepts - //! @defgroup group-Struct Struct - //! The `Struct` concept represents `struct`-like user-defined types. - //! - //! The `Struct` concept allows restricted compile-time reflection over - //! user-defined types. In particular, it allows accessing the names of - //! the members of a user-defined type, and also the value of those - //! members. `Struct`s can also be folded, searched and converted to - //! some types of containers, where more advanced transformations can - //! be performed. - //! - //! While all types can _in theory_ be made `Struct`s, only a subset of - //! them are actually interesting to see as such. More precisely, it is - //! only interesting to make a type a `Struct` when it is conceptually - //! a C++ `struct`, i.e. a mostly dumb aggregate of named data. The way - //! this data is accessed is mostly unimportant to the `Struct` concept; - //! it could be through getters and setters, through public members, - //! through non-member functions or it could even be generated on-the-fly. - //! The important part, which is made precise below, is that those accessor - //! methods should be move-independent. - //! - //! Another way to see a `Struct` is as a map where the keys are the names - //! of the members and the values are the values of those members. However, - //! there are subtle differences like the fact that one can't add a member - //! to a `Struct`, and also that the order of the members inside a `Struct` - //! plays a role in determining the equality of `Struct`s, which is not - //! the case for maps. - //! - //! - //! Minimal complete definition - //! --------------------------- - //! `accessors` - //! - //! A model of `Struct` is created by specifying a sequence of key/value - //! pairs with the `accessors` function. The first element of a pair in - //! this sequence represents the "name" of a member of the `Struct`, while - //! the second element is a function which retrieves this member from an - //! object. The "names" do not have to be in any special form; they just - //! have to be compile-time `Comparable`. For example, it is common to - //! provide "names" that are `hana::string`s representing the actual names - //! of the members, but one could provide `hana::integral_constant`s just - //! as well. The values must be functions which, when given an object, - //! retrieve the appropriate member from it. - //! - //! There are several ways of providing the `accessors` method, some of - //! which are more flexible and others which are more convenient. First, - //! one can define it through tag-dispatching, as usual. - //! @snippet example/struct.mcd.tag_dispatching.cpp main - //! - //! Secondly, it is possible to provide a nested `hana_accessors_impl` - //! type, which should be equivalent to a specialization of - //! `accessors_impl` for tag-dispatching. However, for a type `S`, this - //! technique only works when the data type of `S` is `S` itself, which - //! is the case unless you explicitly asked for something else. - //! @snippet example/struct.mcd.nested.cpp main - //! - //! Finally, the most convenient (but least flexible) option is to use - //! the `BOOST_HANA_DEFINE_STRUCT`, the `BOOST_HANA_ADAPT_STRUCT` or the - //! `BOOST_HANA_ADAPT_ADT` macro, which provide a minimal syntactic - //! overhead. See the documentation of these macros for details on how - //! to use them. - //! - //! Also note that it is not important that the accessor functions retrieve - //! an actual member of the struct (e.g. `x.member`). Indeed, an accessor - //! function could call a custom getter or even compute the value of the - //! member on the fly: - //! @snippet example/struct.custom_accessor.cpp main - //! - //! The only important thing is that the accessor functions are - //! move-independent, a notion which is defined below. - //! - //! - //! @anchor move-independence - //! Move-independence - //! ----------------- - //! The notion of move-independence presented here defines rigorously - //! when it is legitimate to "double-move" from an object. - //! - //! A collection of functions `f1, ..., fn` sharing the same domain is - //! said to be _move-independent_ if for every fresh (not moved-from) - //! object `x` in the domain, any permutation of the following statements - //! is valid and leaves the `zk` objects in a fresh (not moved-from) state: - //! @code - //! auto z1 = f1(std::move(x)); - //! ... - //! auto zn = fn(std::move(x)); - //! @endcode - //! - //! @note - //! In the special case where some functions return objects that can't be - //! bound to with `auto zk =` (like `void` or a non-movable, non-copyable - //! type), just pretend the return value is ignored. - //! - //! Intuitively, this ensures that we can treat `f1, ..., fn` as - //! "accessors" that decompose `x` into independent subobjects, and - //! that do so without moving from `x` more than that subobject. This - //! is important because it allows us to optimally decompose `Struct`s - //! into their subparts inside the library. - //! - //! - //! Laws - //! ---- - //! For any `Struct` `S`, the accessors in the `accessors<S>()` sequence - //! must be move-independent, as defined above. - //! - //! - //! Refined concepts - //! ---------------- - //! 1. `Comparable` (free model)\n - //! `Struct`s are required to be `Comparable`. Specifically, two `Struct`s - //! of the same data type `S` must be equal if and only if all of their - //! members are equal. By default, a model of `Comparable` doing just that - //! is provided for models of `Struct`. In particular, note that the - //! comparison of the members is made in the same order as they appear in - //! the `hana::members` sequence. - //! @include example/struct/comparable.cpp - //! - //! 2. `Foldable` (free model)\n - //! A `Struct` can be folded by considering it as a list of pairs each - //! containing the name of a member and the value associated to that - //! member, in the same order as they appear in the `hana::members` - //! sequence. By default, a model of `Foldable` doing just that is - //! provided for models of the `Struct` concept. - //! @include example/struct/foldable.cpp - //! Being a model of `Foldable` makes it possible to turn a `Struct` - //! into basically any `Sequence`, but also into a `hana::map` by simply - //! using the `to<...>` function! - //! @include example/struct/to.cpp - //! - //! 3. `Searchable` (free model)\n - //! A `Struct` can be searched by considering it as a map where the keys - //! are the names of the members of the `Struct`, and the values are the - //! members associated to those names. By default, a model of `Searchable` - //! is provided for any model of the `Struct` concept. - //! @include example/struct/searchable.cpp - template <typename S> - struct Struct; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONCEPT_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/contains.hpp b/contrib/restricted/boost/boost/hana/fwd/contains.hpp deleted file mode 100644 index eb338281c1..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/contains.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*! -@file -Forward declares `boost::hana::contains` and `boost::hana::in`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CONTAINS_HPP -#define BOOST_HANA_FWD_CONTAINS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/functional/flip.hpp> -#include <boost/hana/functional/infix.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether the key occurs in the structure. - //! @ingroup group-Searchable - //! - //! Given a `Searchable` structure `xs` and a `key`, `contains` returns - //! whether any of the keys of the structure is equal to the given `key`. - //! If the structure is not finite, an equal key has to appear at a finite - //! position in the structure for this method to finish. For convenience, - //! `contains` can also be applied in infix notation. - //! - //! - //! @param xs - //! The structure to search. - //! - //! @param key - //! A key to be searched for in the structure. The key has to be - //! `Comparable` with the other keys of the structure. - //! - //! - //! Example - //! ------- - //! @include example/contains.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto contains = [](auto&& xs, auto&& key) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct contains_impl : contains_impl<S, when<true>> { }; - - struct contains_t { - template <typename Xs, typename Key> - constexpr auto operator()(Xs&& xs, Key&& key) const; - }; - - constexpr auto contains = hana::infix(contains_t{}); -#endif - - //! Return whether the key occurs in the structure. - //! @ingroup group-Searchable - //! - //! Specifically, this is equivalent to `contains`, except `in` takes its - //! arguments in reverse order. Like `contains`, `in` can also be applied - //! in infix notation for increased expressiveness. This function is not a - //! method that can be overriden; it is just a convenience function - //! provided with the concept. - //! - //! - //! Example - //! ------- - //! @include example/in.cpp - constexpr auto in = hana::infix(hana::flip(hana::contains)); -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CONTAINS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core.hpp b/contrib/restricted/boost/boost/hana/fwd/core.hpp deleted file mode 100644 index a25a159582..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core.hpp +++ /dev/null @@ -1,21 +0,0 @@ -/*! -@file -Forward declares the @ref group-core module. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_HPP -#define BOOST_HANA_FWD_CORE_HPP - -#include <boost/hana/fwd/core/common.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/default.hpp> -#include <boost/hana/fwd/core/is_a.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/core/when.hpp> - -#endif // !BOOST_HANA_FWD_CORE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/common.hpp b/contrib/restricted/boost/boost/hana/fwd/core/common.hpp deleted file mode 100644 index d2dcac59f7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/common.hpp +++ /dev/null @@ -1,103 +0,0 @@ -/*! -@file -Forward declares `boost::hana::common` and `boost::hana::common_t`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_COMMON_HPP -#define BOOST_HANA_FWD_CORE_COMMON_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! %Metafunction returning the common data type between two data types. - //! - //! `common` is a natural extension of the `std::common_type` metafunction - //! to data types. Given two data types `T` and `U`, we say that they share - //! a common type `C` if both objects of data type `T` and objects of data - //! type `U` may be converted (using `to`) to an object of data type `C`, - //! and if that conversion is equality preserving. In other words, this - //! means that for any objects `t1, t2` of data type `T` and `u1, u2` of - //! data type `U`, the following law is satisfied: - //! @code - //! to<C>(t1) == to<C>(t2) if and only if t1 == t2 - //! to<C>(u1) == to<C>(u2) if and only if u1 == u2 - //! @endcode - //! - //! The role of `common` is to provide an alias to such a `C` if it exists. - //! In other words, if `T` and `U` have a common data type `C`, - //! `common<T, U>::%type` is an alias to `C`. Otherwise, `common<T, U>` - //! has no nested `type` and can be used in dependent contexts to exploit - //! SFINAE. By default, the exact steps followed by `common` to determine - //! the common type `C` of `T` and `U` are - //! 1. If `T` and `U` are the same, then `C` is `T`. - //! 2. Otherwise, if `true ? std::declval<T>() : std::declval<U>()` is - //! well-formed, then `C` is the type of this expression after using - //! `std::decay` on it. This is exactly the type that would have been - //! returned by `std::common_type`, except that custom specializations - //! of `std::common_type` are not taken into account. - //! 3. Otherwise, no common data type is detected and `common<T, U>` does - //! not have a nested `type` alias, unless it is specialized explicitly. - //! - //! As point 3 suggests, it is also possible (and sometimes necessary) to - //! specialize `common` in the `boost::hana` namespace for pairs of custom - //! data types when the default behavior of `common` is not sufficient. - //! Note that `when`-based specialization is supported when specializing - //! `common` in the `boost::hana` namespace. - //! - //! > #### Rationale for requiring the conversion to be equality-preserving - //! > This decision is aligned with a proposed concept design for the - //! > standard library ([N3351][1]). Also, if we did not require this, - //! > then all data types would trivially share the common data type - //! > `void`, since all objects can be converted to it. - //! - //! - //! Example - //! ------- - //! @include example/core/common/common.cpp - //! - //! - //! [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, typename U, optional when-based enabler> - struct common { see documentation }; -#else - template <typename T, typename U, typename = void> - struct common; -#endif - - //! @ingroup group-core - //! %Metafunction returning whether two data types share a common data type. - //! - //! Given two data types `T` and `U`, this metafunction simply returns - //! whether `common<T, U>::%type` is well-formed. - //! - //! - //! Example - //! ------- - //! @include example/core/common/has_common.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, typename U> - struct has_common { whether common<T, U>::type is well-formed }; -#else - template <typename T, typename U, typename = void> - struct has_common; -#endif - - //! @ingroup group-core - //! Alias to `common<T, U>::%type`, provided for convenience. - //! - //! - //! Example - //! ------- - //! @include example/core/common/common_t.cpp - template <typename T, typename U> - using common_t = typename common<T, U>::type; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_COMMON_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/default.hpp b/contrib/restricted/boost/boost/hana/fwd/core/default.hpp deleted file mode 100644 index 978c9a5f0c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/default.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Forward declares `boost::hana::default_` and `boost::hana::is_default`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_DEFAULT_HPP -#define BOOST_HANA_FWD_CORE_DEFAULT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! Mark a tag-dispatched method implementation as a default implementation. - //! - //! When defining a new concept with tag-dispatched methods, it is - //! sometimes possible to provide a default implementation for some - //! method(s). Making `default_` a base class of such a default - //! implementation makes it possible to detect whether the method - //! was dispatched to the default implementation afterwards. - //! - //! - //! Example - //! ------- - //! @include example/core/default.cpp - struct default_ { }; - - //! @ingroup group-core - //! Returns whether a tag-dispatched method implementation is a default - //! implementation. - //! - //! Given a tag-dispatched method implementation `method_impl<T...>`, - //! `is_default<method_impl<T...>>` returns whether `method_impl<T...>` - //! is a default implementation. Note that if there is no default - //! implementation for the method, then `is_default` should not be - //! used unless a static assertion saying that "the method is not - //! implemented" is acceptable. - //! - //! - //! Example - //! ------- - //! @include example/core/default.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename Method> - struct is_default { see documentation }; -#else - template <typename T, typename = void> - struct is_default; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_DEFAULT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/is_a.hpp b/contrib/restricted/boost/boost/hana/fwd/core/is_a.hpp deleted file mode 100644 index 956549aa16..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/is_a.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Forward declares `boost::hana::is_a` and `boost::hana::is_an`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_IS_A_HPP -#define BOOST_HANA_FWD_CORE_IS_A_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! Returns whether the tag of an object matches a given tag. - //! - //! Given a tag `Tag` and a C++ type `T`, `is_a<Tag, T>` is a compile-time - //! Logical representing whether the tag of `T` is exactly `Tag`. In other - //! words, it is equivalent to - //! @code - //! std::is_same<Tag, tag_of<T>::type> - //! @endcode - //! - //! For convenience, an alternate syntax is provided for using `is_a`. - //! Specifically, `is_a<Tag>` is a function object returning whether the - //! argument it is passed has the given tag. In other words, - //! @code - //! is_a<Tag>(x) == is_a<Tag, decltype(x)> - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/core/is_a.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename Tag, typename optional_T> - constexpr auto is_a = see-documentation; -#else - template <typename Tag, typename ...T> - struct is_a_t; - - template <typename Tag, typename ...T> - constexpr is_a_t<Tag, T...> is_a{}; -#endif - - //! @ingroup group-core - //! Equivalent to `is_a`; provided for consistency with the rules of the - //! English language. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename Tag, typename ...T> - constexpr auto is_an = is_a<Tag, T...>; -#else - template <typename Tag, typename ...T> - constexpr is_a_t<Tag, T...> is_an{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_IS_A_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/make.hpp b/contrib/restricted/boost/boost/hana/fwd/core/make.hpp deleted file mode 100644 index 0ed5d0f19e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/make.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Forward declares `boost::hana::make`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_MAKE_HPP -#define BOOST_HANA_FWD_CORE_MAKE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! Create an object of the given tag with the given arguments. - //! - //! This function serves the same purpose as constructors in usual C++. - //! However, instead of creating an object of a specific C++ type, it - //! creates an object of a specific tag, regardless of the C++ type - //! of that object. - //! - //! This function is actually a variable template, so `make<T>` can be - //! passed around as a function object creating an object of tag `T`. - //! Also, it uses tag-dispatching so this is how it should be customized - //! for user-defined tags. - //! - //! Finally, the default implementation of `make` is equivalent to calling - //! the constructor of the given tag with the corresponding arguments. - //! In other words, by default, - //! @code - //! make<T>(args...) == T(args...) - //! @endcode - //! - //! Note that the arguments are perfectly forwarded and the form of - //! construction which is used is exactly as documented, i.e. `T(args...)`. - //! However, if `T(args...)` is not a valid expression, a compilation - //! error is triggered. This default behavior is useful because it makes - //! foreign C++ types that have no notion of tag constructible with `make` - //! out-of-the-box, since their tag is exactly themselves. - //! - //! - //! Example - //! ------- - //! @include example/core/make.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename Tag> - constexpr auto make = [](auto&& ...x) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename Tag, typename = void> - struct make_impl; - - template <typename Tag> - struct make_t { - template <typename ...X> - constexpr decltype(auto) operator()(X&& ...x) const { - return make_impl<Tag>::apply(static_cast<X&&>(x)...); - } - }; - - template <typename Tag> - constexpr make_t<Tag> make{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_MAKE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/tag_of.hpp b/contrib/restricted/boost/boost/hana/fwd/core/tag_of.hpp deleted file mode 100644 index 5d490dd717..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/tag_of.hpp +++ /dev/null @@ -1,120 +0,0 @@ -/*! -@file -Forward declares `boost::hana::tag_of` and `boost::hana::tag_of_t`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_TAG_OF_HPP -#define BOOST_HANA_FWD_CORE_TAG_OF_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! %Metafunction returning the tag associated to `T`. - //! - //! There are several ways to specify the tag of a C++ type. If it's a - //! user-defined type, one can define a nested `hana_tag` alias: - //! @code - //! struct MyUserDefinedType { - //! using hana_tag = MyTag; - //! }; - //! @endcode - //! - //! Sometimes, however, the C++ type can't be modified (if it's in a - //! foreign library) or simply can't have nested types (if it's not a - //! struct or class). In those cases, using a nested alias is impossible - //! and so ad-hoc customization is also supported by specializing - //! `tag_of` in the `boost::hana` namespace: - //! @code - //! struct i_cant_modify_this; - //! - //! namespace boost { namespace hana { - //! template <> - //! struct tag_of<i_cant_modify_this> { - //! using type = MyTag; - //! }; - //! }} - //! @endcode - //! - //! `tag_of` can also be specialized for all C++ types satisfying some - //! boolean condition using `when`. `when` accepts a single compile-time - //! boolean and enables the specialization of `tag_of` if and only if - //! that boolean is `true`. This is similar to the well known C++ idiom - //! of using a dummy template parameter with `std::enable_if` and relying - //! on SFINAE. For example, we could specify the tag of all - //! `fusion::vector`s by doing: - //! @code - //! struct BoostFusionVector; - //! - //! namespace boost { namespace hana { - //! template <typename T> - //! struct tag_of<T, when< - //! std::is_same< - //! typename fusion::traits::tag_of<T>::type, - //! fusion::traits::tag_of<fusion::vector<>>::type - //! >::value - //! >> { - //! using type = BoostFusionVector; - //! }; - //! }} - //! @endcode - //! - //! Also, when it is not specialized and when the given C++ type does not - //! have a nested `hana_tag` alias, `tag_of<T>` returns `T` itself. This - //! makes tags a simple extension of normal C++ types. This is _super_ - //! useful, mainly for two reasons. First, this allows Hana to adopt a - //! reasonable default behavior for some operations involving types that - //! have no notion of tags. For example, Hana allows comparing with `equal` - //! any two objects for which a valid `operator==` is defined, and that - //! without any work on the user side. Second, it also means that you can - //! ignore tags completely if you don't need their functionality; just use - //! the normal C++ type of your objects and everything will "just work". - //! - //! Finally, also note that `tag_of<T>` is always equivalent to `tag_of<U>`, - //! where `U` is the type `T` after being stripped of all references and - //! cv-qualifiers. This makes it unnecessary to specialize `tag_of` for - //! all reference and cv combinations, which would be a real pain. Also, - //! `tag_of` is required to be idempotent. In other words, it must always - //! be the case that `tag_of<tag_of<T>::%type>::%type` is equivalent to - //! `tag_of<T>::%type`. - //! - //! > __Tip 1__\n - //! > If compile-time performance is a serious concern, consider - //! > specializing the `tag_of` metafunction in Hana's namespace. - //! > When unspecialized, the metafunction has to use SFINAE, which - //! > tends to incur a larger compile-time overhead. For heavily used - //! > templated types, this can potentially make a difference. - //! - //! > __Tip 2__\n - //! > Consider using `tag_of_t` alias instead of `tag_of`, which - //! > reduces the amount of typing in dependent contexts. - //! - //! - //! Example - //! ------- - //! @include example/core/tag_of.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, optional when-based enabler> - struct tag_of { unspecified }; -#else - template <typename T, typename = void> - struct tag_of; -#endif - - //! @ingroup group-core - //! Alias to `tag_of<T>::%type`, provided for convenience. - //! - //! - //! Example - //! ------- - //! @include example/core/tag_of_t.cpp - template <typename T> - using tag_of_t = typename hana::tag_of<T>::type; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_TAG_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/to.hpp b/contrib/restricted/boost/boost/hana/fwd/core/to.hpp deleted file mode 100644 index 108484c2ce..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/to.hpp +++ /dev/null @@ -1,174 +0,0 @@ -/*! -@file -Forward declares `boost::hana::to` and related utilities. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_TO_HPP -#define BOOST_HANA_FWD_CORE_TO_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! Converts an object from one data type to another. - //! - //! `to` is a natural extension of the `static_cast` language construct to - //! data types. Given a destination data type `To` and an object `x`, `to` - //! creates a new object of data type `To` from `x`. Note, however, that - //! `to` is not required to actually create a new object, and may return a - //! reference to the original object (for example when trying to convert - //! an object to its own data type). - //! - //! As a natural extension to `static_cast`, `to` provides a default - //! behavior. For the purpose of what follows, let `To` be the destination - //! data type and `From` be the data type of `x`, i.e. the source data type. - //! Then, `to` has the following default behavior: - //! 1. If the `To` and `From` data types are the same, then the object - //! is forwarded as-is. - //! 2. Otherwise, if `From` is convertible to `To` using `static_cast`, - //! `x` is converted to `From` using `static_cast`. - //! 3. Otherwise, calling `to<From>(x)` triggers a static assertion. - //! - //! However, `to` is a tag-dispatched function, which means that `to_impl` - //! may be specialized in the `boost::hana` namespace to customize its - //! behavior for arbitrary data types. Also note that `to` is tag-dispatched - //! using both the `To` and the `From` data types, which means that `to_impl` - //! is called as `to_impl<To, From>::%apply(x)`. Also note that some - //! concepts provide conversions to or from their models. For example, - //! any `Foldable` may be converted into a `Sequence`. This is achieved - //! by specializing `to_impl<To, From>` whenever `To` is a `Sequence` and - //! `From` is a `Foldable`. When such conversions are provided, they are - //! documented in the source concept, in this case `Foldable`. - //! - //! - //! Hana-convertibility - //! ------------------- - //! When an object `x` of data type `From` can be converted to a data type - //! `To` using `to`, we say that `x` is Hana-convertible to the data type - //! `To`. We also say that there is a Hana-conversion from `From` to `To`. - //! This bit of terminology is useful to avoid mistaking the various kinds - //! of conversions C++ offers. - //! - //! - //! Embeddings - //! ---------- - //! As you might have seen by now, Hana uses algebraic and category- - //! theoretical structures all around the place to help specify concepts - //! in a rigorous way. These structures always have operations associated - //! to them, which is why they are useful. The notion of embedding captures - //! the idea of injecting a smaller structure into a larger one while - //! preserving the operations of the structure. In other words, an - //! embedding is an injective mapping that is also structure-preserving. - //! Exactly what it means for a structure's operations to be preserved is - //! left to explain by the documentation of each structure. For example, - //! when we talk of a Monoid-embedding from a Monoid `A` to a Monoid `B`, - //! we simply mean an injective transformation that preserves the identity - //! and the associative operation, as documented in `Monoid`. - //! - //! But what does this have to do with the `to` function? Quite simply, - //! the `to` function is a mapping between two data types, which will - //! sometimes be some kind of structure, and it is sometimes useful to - //! know whether such a mapping is well-behaved, i.e. lossless and - //! structure preserving. The criterion for this conversion to be well- - //! behaved is exactly that of being an embedding. To specify that a - //! conversion is an embedding, simply use the `embedding` type as a - //! base class of the corresponding `to_impl` specialization. Obviously, - //! you should make sure the conversion is really an embedding, unless - //! you want to shoot yourself in the foot. - //! - //! - //! @tparam To - //! The data type to which `x` should be converted. - //! - //! @param x - //! The object to convert to the given data type. - //! - //! - //! Example - //! ------- - //! @include example/core/convert/to.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename To> - constexpr auto to = [](auto&& x) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename To, typename From, typename = void> - struct to_impl; - - template <typename To> - struct to_t { - template <typename X> - constexpr decltype(auto) operator()(X&& x) const; - }; - - template <typename To> - constexpr to_t<To> to{}; -#endif - - //! @ingroup group-core - //! Returns whether there is a Hana-conversion from a data type to another. - //! - //! Specifically, `is_convertible<From, To>` is whether calling `to<To>` - //! with an object of data type `From` would _not_ trigger a static - //! assertion. - //! - //! - //! Example - //! ------- - //! @include example/core/convert/is_convertible.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename From, typename To> - struct is_convertible { see documentation }; -#else - template <typename From, typename To, typename = void> - struct is_convertible; -#endif - - //! @ingroup group-core - //! Marks a conversion between data types as being an embedding. - //! - //! To mark a conversion between two data types `To` and `From` as - //! an embedding, simply use `embedding<true>` (or simply `embedding<>`) - //! as a base class of the corresponding `to_impl` specialization. - //! If a `to_impl` specialization does not inherit `embedding<true>` - //! or `embedding<>`, then it is not considered an embedding by the - //! `is_embedded` metafunction. - //! - //! > #### Tip - //! > The boolean template parameter is useful for marking a conversion - //! > as an embedding only when some condition is satisfied. - //! - //! - //! Example - //! ------- - //! @include example/core/convert/embedding.cpp - template <bool = true> - struct embedding { }; - - //! @ingroup group-core - //! Returns whether a data type can be embedded into another data type. - //! - //! Given two data types `To` and `From`, `is_embedded<From, To>` returns - //! whether `From` is convertible to `To`, and whether that conversion is - //! also an embedding, as signaled by the `embedding` type. - //! - //! - //! Example - //! ------- - //! @include example/core/convert/is_embedded.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename From, typename To> - struct is_embedded { see documentation }; -#else - template <typename From, typename To, typename = void> - struct is_embedded; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_TO_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/core/when.hpp b/contrib/restricted/boost/boost/hana/fwd/core/when.hpp deleted file mode 100644 index cc7659628d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/core/when.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Forward declares `boost::hana::when` and `boost::hana::when_valid`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CORE_WHEN_HPP -#define BOOST_HANA_FWD_CORE_WHEN_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-core - //! Enable a partial specialization only if a boolean condition is true. - //! - //! You might also want to take a look at `when_valid`, which provides - //! similar functionality but enables a specialziation only when some - //! expression is well-formed. - //! - //! > #### Rationale for using `when` instead of `std::enable_if` - //! > `when` is used to control the priority of partial specializations - //! > in a finer grained manner than what can be achieved with the usual - //! > `typename Enable = void` and `std::enable_if` pattern. For example, - //! > a partially specialized tag-dispatched method will have a higher - //! > priority than an equivalent specialization that uses `when`. For - //! > more details, see the tutorial section on [tag-dispatching][1]. - //! - //! - //! Example - //! ------- - //! @include example/core/when.cpp - //! - //! [1]: @ref tutorial-core-tag_dispatching - template <bool condition> - struct when; - - namespace core_detail { - template <typename ...> - struct always_true { static constexpr bool value = true; }; - } - - //! @ingroup group-core - //! Variant of `when` allowing specializations to be enabled only if an - //! expression is well-formed. - //! - //! `when_valid<...>` is always equivalent to `when<true>`. However, when - //! used inside a partial specialization, SFINAE will cause the partial - //! specialization to be ignored when the expression is ill-formed. - //! - //! - //! Example - //! ------- - //! @include example/core/when_valid.cpp - //! - //! - //! @bug - //! Using `when_valid` seems to trigger ambiguous partial specializations - //! on GCC. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename ...> - using when_valid = when<true>; -#else - template <typename ...Dummy> - using when_valid = when< - core_detail::always_true<Dummy...>::value - >; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CORE_WHEN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/count.hpp b/contrib/restricted/boost/boost/hana/fwd/count.hpp deleted file mode 100644 index 3bfdda53d6..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/count.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::count`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_COUNT_HPP -#define BOOST_HANA_FWD_COUNT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the number of elements in the structure that compare equal to - //! a given value. - //! @ingroup group-Foldable - //! - //! Given a Foldable structure `xs` and a value `value`, `count` returns - //! an unsigned integral, or a Constant thereof, representing the number - //! of elements of `xs` that compare equal to `value`. For this method to - //! be well-defined, all the elements of the structure must be Comparable - //! with the given value. - //! - //! - //! @param xs - //! The structure whose elements are counted. - //! - //! @param value - //! A value compared with each element in the structure. Elements - //! that compare equal to this value are counted, others are not. - //! - //! - //! Example - //! ------- - //! @include example/count.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto count = [](auto&& xs, auto&& value) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct count_impl : count_impl<T, when<true>> { }; - - struct count_t { - template <typename Xs, typename Value> - constexpr auto operator()(Xs&& xs, Value&& value) const; - }; - - constexpr count_t count{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_COUNT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/count_if.hpp b/contrib/restricted/boost/boost/hana/fwd/count_if.hpp deleted file mode 100644 index 8be0a42638..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/count_if.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Forward declares `boost::hana::count_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_COUNT_IF_HPP -#define BOOST_HANA_FWD_COUNT_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the number of elements in the structure for which the - //! `predicate` is satisfied. - //! @ingroup group-Foldable - //! - //! Specifically, returns an object of an unsigned integral type, or - //! a `Constant` holding such an object, which represents the number - //! of elements in the structure satisfying the given `predicate`. - //! - //! - //! @param xs - //! The structure whose elements are counted. - //! - //! @param predicate - //! A function called as `predicate(x)`, where `x` is an element of the - //! structure, and returning a `Logical` representing whether `x` should - //! be counted. - //! - //! - //! Example - //! ------- - //! @include example/count_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto count_if = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct count_if_impl : count_if_impl<T, when<true>> { }; - - struct count_if_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr count_if_t count_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_COUNT_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/cycle.hpp b/contrib/restricted/boost/boost/hana/fwd/cycle.hpp deleted file mode 100644 index 268e7daf43..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/cycle.hpp +++ /dev/null @@ -1,76 +0,0 @@ -/*! -@file -Forward declares `boost::hana::cycle`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_CYCLE_HPP -#define BOOST_HANA_FWD_CYCLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Combine a monadic structure with itself `n` times. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and a non-negative number `n`, - //! `cycle` returns a new monadic structure which is the result of - //! combining `xs` with itself `n` times using the `concat` operation. - //! In other words, - //! @code - //! cycle(xs, n) == concat(xs, concat(xs, ... concat(xs, xs))) - //! // ^^^^^ n times total - //! @endcode - //! - //! Also note that since `concat` is required to be associative, we - //! could also have written - //! @code - //! cycle(xs, n) == concat(concat(... concat(xs, xs), xs), xs) - //! // ^^^^^ n times total - //! @endcode - //! - //! If `n` is zero, then the identity of `concat`, `empty`, is returned. - //! In the case of sequences, this boils down to returning a sequence - //! containing `n` copies of itself; for other models it might differ. - //! - //! - //! Signature - //! --------- - //! Given an `IntegralConstant` `C` and a `MonadPlus` `M`, the signature is - //! @f$ \mathrm{cycle} : M(T) \times C \to M(T) @f$. - //! - //! @param xs - //! A monadic structure to combine with itself a certain number of times. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of times to - //! combine the monadic structure with itself. If `n` is zero, `cycle` - //! returns `empty`. - //! - //! - //! Example - //! ------- - //! @include example/cycle.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto cycle = [](auto&& xs, auto const& n) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct cycle_impl : cycle_impl<M, when<true>> { }; - - struct cycle_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - }; - - constexpr cycle_t cycle{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_CYCLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/define_struct.hpp b/contrib/restricted/boost/boost/hana/fwd/define_struct.hpp deleted file mode 100644 index 831f6872a4..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/define_struct.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Documents the `BOOST_HANA_DEFINE_STRUCT` macro. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DEFINE_STRUCT_HPP -#define BOOST_HANA_FWD_DEFINE_STRUCT_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: - // The weird definition as a variable seems to exploit a glitch in Doxygen - // which makes the macro appear in the related objects of Struct (as we - // want it to). - - //! Defines members of a structure, while at the same time - //! modeling `Struct`. - //! @ingroup group-Struct - //! - //! Using this macro in the body of a user-defined type will define the - //! given members inside that type, and will also provide a model of the - //! `Struct` concept for that user-defined type. This macro is often the - //! easiest way to define a model of the `Struct` concept. - //! - //! @note - //! This macro only works if the tag of the user-defined type `T` is `T` - //! itself. This is the case unless you specifically asked for something - //! different; see `tag_of`'s documentation. - //! - //! - //! Example - //! ------- - //! @include example/define_struct.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto BOOST_HANA_DEFINE_STRUCT(...) = ; - #define BOOST_HANA_DEFINE_STRUCT(Name, ...) see documentation -#else - // defined in <boost/hana/define_struct.hpp> -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DEFINE_STRUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/difference.hpp b/contrib/restricted/boost/boost/hana/fwd/difference.hpp deleted file mode 100644 index d96142b5b9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/difference.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Forward declares `boost::hana::difference`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DIFFERENCE_HPP -#define BOOST_HANA_FWD_DIFFERENCE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename S, typename = void> - struct difference_impl : difference_impl<S, when<true>> { }; - //! @endcond - - struct difference_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&&, Ys&&) const; - }; - - constexpr difference_t difference{}; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DIFFERENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/div.hpp b/contrib/restricted/boost/boost/hana/fwd/div.hpp deleted file mode 100644 index 6f35b4abe3..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/div.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/*! -@file -Forward declares `boost::hana::div`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DIV_HPP -#define BOOST_HANA_FWD_DIV_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Generalized integer division. - //! @ingroup group-EuclideanRing - //! - //! - //! Cross-type version of the method - //! -------------------------------- - //! The `div` method is "overloaded" to handle distinct data types - //! with certain properties. Specifically, `div` is defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually - //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as - //! determined by the `is_embedding` metafunction. - //! - //! In that case, the `div` method is defined as - //! @code - //! div(x, y) = div(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/div.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto div = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct div_impl : div_impl<T, U, when<true>> { }; - - struct div_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr div_t div{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DIV_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/drop_back.hpp b/contrib/restricted/boost/boost/hana/fwd/drop_back.hpp deleted file mode 100644 index 440e925322..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/drop_back.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::drop_back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DROP_BACK_HPP -#define BOOST_HANA_FWD_DROP_BACK_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Drop the last `n` elements of a finite sequence, and return the rest. - //! @ingroup group-Sequence - //! - //! Given a finite `Sequence` `xs` with a linearization of `[x1, ..., xm]` - //! and a non-negative `IntegralConstant` `n`, `drop_back(xs, n)` is a - //! sequence with the same tag as `xs` whose linearization is - //! `[x1, ..., xm-n]`. If `n` is not given, it defaults to an - //! `IntegralConstant` with a value equal to `1`. - //! - //! In case `length(xs) <= n`, `drop_back` will simply drop the whole - //! sequence without failing, thus returning an empty sequence. - //! - //! - //! @param xs - //! The sequence from which elements are dropped. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of elements - //! to be dropped from the end of the sequence. If `n` is not given, it - //! defaults to an `IntegralConstant` with a value equal to `1`. - //! - //! - //! Example - //! ------- - //! @include example/drop_back.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto drop_back = [](auto&& xs[, auto const& n]) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct drop_back_impl : drop_back_impl<S, when<true>> { }; - - struct drop_back_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr drop_back_t drop_back{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DROP_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/drop_front.hpp b/contrib/restricted/boost/boost/hana/fwd/drop_front.hpp deleted file mode 100644 index 298499180c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/drop_front.hpp +++ /dev/null @@ -1,66 +0,0 @@ -/*! -@file -Forward declares `boost::hana::drop_front`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DROP_FRONT_HPP -#define BOOST_HANA_FWD_DROP_FRONT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Drop the first `n` elements of an iterable, and return the rest. - //! @ingroup group-Iterable - //! - //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and - //! a non-negative `IntegralConstant` `n`, `drop_front(xs, n)` is an - //! iterable with the same tag as `xs` whose linearization is - //! `[xn+1, xn+2, ...]`. In particular, note that this function does not - //! mutate the original iterable in any way. If `n` is not given, it - //! defaults to an `IntegralConstant` with a value equal to `1`. - //! - //! In case `length(xs) <= n`, `drop_front` will simply drop the whole - //! iterable without failing, thus returning an empty iterable. This is - //! different from `drop_front_exactly`, which expects `n <= length(xs)` - //! but can be better optimized because of this additional guarantee. - //! - //! - //! @param xs - //! The iterable from which elements are dropped. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of elements - //! to be dropped from the iterable. If `n` is not given, it defaults to - //! an `IntegralConstant` with a value equal to `1`. - //! - //! - //! Example - //! ------- - //! @include example/drop_front.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto drop_front = [](auto&& xs[, auto const& n]) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct drop_front_impl : drop_front_impl<It, when<true>> { }; - - struct drop_front_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr drop_front_t drop_front{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DROP_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/drop_front_exactly.hpp b/contrib/restricted/boost/boost/hana/fwd/drop_front_exactly.hpp deleted file mode 100644 index 17a55e6d66..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/drop_front_exactly.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*! -@file -Forward declares `boost::hana::drop_front_exactly`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP -#define BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Drop the first `n` elements of an iterable, and return the rest. - //! @ingroup group-Iterable - //! - //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and - //! a non-negative `IntegralConstant` `n`, `drop_front_exactly(xs, n)` is - //! an iterable with the same tag as `xs` whose linearization is - //! `[xn+1, xn+2, ...]`. In particular, note that this function does not - //! mutate the original iterable in any way. If `n` is not given, it - //! defaults to an `IntegralConstant` with a value equal to `1`. - //! - //! It is an error to use `drop_front_exactly` with `n > length(xs)`. This - //! additional guarantee allows `drop_front_exactly` to be better optimized - //! than the `drop_front` function, which allows `n > length(xs)`. - //! - //! - //! @param xs - //! The iterable from which elements are dropped. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of elements - //! to be dropped from the iterable. In addition to being non-negative, - //! `n` must be less than or equal to the number of elements in `xs`. - //! If `n` is not given, it defaults to an `IntegralConstant` with a value - //! equal to `1`. - //! - //! - //! Example - //! ------- - //! @include example/drop_front_exactly.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto drop_front_exactly = [](auto&& xs[, auto const& n]) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct drop_front_exactly_impl : drop_front_exactly_impl<It, when<true>> { }; - - struct drop_front_exactly_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr drop_front_exactly_t drop_front_exactly{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/drop_while.hpp b/contrib/restricted/boost/boost/hana/fwd/drop_while.hpp deleted file mode 100644 index 2d5557e5a7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/drop_while.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/*! -@file -Forward declares `boost::hana::drop_while`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DROP_WHILE_HPP -#define BOOST_HANA_FWD_DROP_WHILE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Drop elements from an iterable up to, but excluding, the first - //! element for which the `predicate` is not satisfied. - //! @ingroup group-Iterable - //! - //! Specifically, `drop_while` returns an iterable containing all the - //! elements of the original iterable except for those in the range - //! delimited by [`head`, `e`), where `head` is the first element and - //! `e` is the first element for which the `predicate` is not satisfied. - //! If the iterable is not finite, the `predicate` has to return a false- - //! valued `Logical` at a finite index for this method to return. - //! - //! - //! @param iterable - //! The iterable from which elements are dropped. - //! - //! @param predicate - //! A function called as `predicate(x)`, where `x` is an element of the - //! structure, and returning a `Logical` representing whether `x` should - //! be dropped from the structure. In the current version of the library, - //! `predicate` should return a compile-time `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/drop_while.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto drop_while = [](auto&& iterable, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct drop_while_impl : drop_while_impl<It, when<true>> { }; - - struct drop_while_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr drop_while_t drop_while{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWDDROP_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/duplicate.hpp b/contrib/restricted/boost/boost/hana/fwd/duplicate.hpp deleted file mode 100644 index bac61e0bd9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/duplicate.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::duplicate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_DUPLICATE_HPP -#define BOOST_HANA_FWD_DUPLICATE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Add an extra layer of comonadic context to a comonadic value. - //! @ingroup group-Comonad - //! - //! Given a value already in a comonadic context, `duplicate` wraps this - //! value with an additional layer of comonadic context. This can be seen - //! as the dual operation to `flatten` from the Monad concept. - //! - //! - //! Signature - //! --------- - //! Given a Comonad `W`, the signature is - //! \f$ - //! \mathtt{duplicate} : W(T) \to W(W(T)) - //! \f$ - //! - //! @param w - //! The value to wrap in an additional level of comonadic context. - //! - //! - //! Example - //! ------- - //! @include example/duplicate.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto duplicate = [](auto&& w) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename W, typename = void> - struct duplicate_impl : duplicate_impl<W, when<true>> { }; - - struct duplicate_t { - template <typename W_> - constexpr decltype(auto) operator()(W_&& w) const; - }; - - constexpr duplicate_t duplicate{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_DUPLICATE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/empty.hpp b/contrib/restricted/boost/boost/hana/fwd/empty.hpp deleted file mode 100644 index ed3cc38cc7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/empty.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Forward declares `boost::hana::empty`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EMPTY_HPP -#define BOOST_HANA_FWD_EMPTY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Identity of the monadic combination `concat`. - //! @ingroup group-MonadPlus - //! - //! Signature - //! --------- - //! Given a MonadPlus `M`, the signature is - //! @f$ \mathtt{empty}_M : \emptyset \to M(T) @f$. - //! - //! @tparam M - //! The tag of the monadic structure to return. This must be - //! a model of the MonadPlus concept. - //! - //! - //! Example - //! ------- - //! @include example/empty.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto empty = []() { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct empty_impl : empty_impl<M, when<true>> { }; - - template <typename M> - struct empty_t; - - template <typename M> - constexpr empty_t<M> empty{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EMPTY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/equal.hpp b/contrib/restricted/boost/boost/hana/fwd/equal.hpp deleted file mode 100644 index e9f8c4bd6e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/equal.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/*! -@file -Forward declares `boost::hana::equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EQUAL_HPP -#define BOOST_HANA_FWD_EQUAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_to_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is equal to `y`. - //! @ingroup group-Comparable - //! - //! The `equal` function can be called in two different ways. First, it - //! can be called like a normal function: - //! @code - //! equal(x, y) - //! @endcode - //! - //! However, it may also be partially applied to an argument by using - //! `equal.to`: - //! @code - //! equal.to(x)(y) == equal(x, y) - //! @endcode - //! - //! In other words, `equal.to(x)` is a function object that is equivalent - //! to `partial(equal, x)`. This is provided to enhance the readability of - //! some constructs, especially when using higher order algorithms. - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Comparables `A` and `B` that - //! share a common embedding, the signature is - //! @f$ \mathtt{equal} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare for equality. - //! - //! - //! Example - //! ------- - //! @include example/equal.cpp - //! - //! - //! > #### Rationale for the arity of `equal` - //! > It is a valid question whether `equal` should accept more than 2 - //! > arguments and have semantics matching those of Python's `==`. This - //! > is not supported right now for the following reasons: - //! > - It was implemented in the MPL11, but it was not shown to be useful - //! > so far. - //! > - It does not make sense for `not_equal` to have an arity of more - //! > than 2, only `equal` could maybe have those semantics, which would - //! > break symmetry. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto equal = [](auto&& x, auto&& y) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct equal_impl : equal_impl<T, U, when<true>> { }; - - struct equal_t : detail::nested_to<equal_t> { - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) const; - }; - - constexpr equal_t equal{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/erase_key.hpp b/contrib/restricted/boost/boost/hana/fwd/erase_key.hpp deleted file mode 100644 index 49471d61cf..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/erase_key.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Forward declares `boost::hana::erase_key`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ERASE_KEY_HPP -#define BOOST_HANA_FWD_ERASE_KEY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename T, typename = void> - struct erase_key_impl : erase_key_impl<T, when<true>> { }; - //! @endcond - - struct erase_key_t { - template <typename Set, typename ...Args> - constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; - }; - - constexpr erase_key_t erase_key{}; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ERASE_KEY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/eval.hpp b/contrib/restricted/boost/boost/hana/fwd/eval.hpp deleted file mode 100644 index d068f992f5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/eval.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Forward declares `boost::hana::eval`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EVAL_HPP -#define BOOST_HANA_FWD_EVAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Evaluate a lazy value and return it. - //! @relates hana::lazy - //! - //! Given a lazy expression `expr`, `eval` evaluates `expr` and returns - //! the result as a normal value. However, for convenience, `eval` can - //! also be used with nullary and unary function objects. Specifically, - //! if `expr` is not a `hana::lazy`, it is called with no arguments at - //! all and the result of that call (`expr()`) is returned. Otherwise, - //! if `expr()` is ill-formed, then `expr(hana::id)` is returned instead. - //! If that expression is ill-formed, then a compile-time error is - //! triggered. - //! - //! The reason for allowing nullary callables in `eval` is because this - //! allows using nullary lambdas as lazy branches to `eval_if`, which - //! is convenient. The reason for allowing unary callables and calling - //! them with `hana::id` is because this allows deferring the - //! compile-time evaluation of selected expressions inside the callable. - //! How this can be achieved is documented by `hana::eval_if`. - //! - //! - //! Example - //! ------- - //! @include example/eval.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto eval = [](auto&& see_documentation) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct eval_impl : eval_impl<T, when<true>> { }; - - struct eval_t { - template <typename Expr> - constexpr decltype(auto) operator()(Expr&& expr) const; - }; - - constexpr eval_t eval{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EVAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/eval_if.hpp b/contrib/restricted/boost/boost/hana/fwd/eval_if.hpp deleted file mode 100644 index 2bc8736b12..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/eval_if.hpp +++ /dev/null @@ -1,155 +0,0 @@ -/*! -@file -Forward declares `boost::hana::eval_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EVAL_IF_HPP -#define BOOST_HANA_FWD_EVAL_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Conditionally execute one of two branches based on a condition. - //! @ingroup group-Logical - //! - //! Given a condition and two branches in the form of lambdas or - //! `hana::lazy`s, `eval_if` will evaluate the branch selected by the - //! condition with `eval` and return the result. The exact requirements - //! for what the branches may be are the same requirements as those for - //! the `eval` function. - //! - //! - //! Deferring compile-time evaluation inside `eval_if` - //! -------------------------------------------------- - //! By passing a unary callable to `eval_if`, it is possible to defer - //! the compile-time evaluation of selected expressions inside the - //! lambda. This is useful when instantiating a branch would trigger - //! a compile-time error; we only want the branch to be instantiated - //! when that branch is selected. Here's how it can be achieved. - //! - //! For simplicity, we'll use a unary lambda as our unary callable. - //! Our lambda must accept a parameter (usually called `_`), which - //! can be used to defer the compile-time evaluation of expressions - //! as required. For example, - //! @code - //! template <typename N> - //! auto fact(N n) { - //! return hana::eval_if(n == hana::int_c<0>, - //! [] { return hana::int_c<1>; }, - //! [=](auto _) { return n * fact(_(n) - hana::int_c<1>); } - //! ); - //! } - //! @endcode - //! - //! What happens here is that `eval_if` will call `eval` on the selected - //! branch. In turn, `eval` will call the selected branch either with - //! nothing -- for the _then_ branch -- or with `hana::id` -- for the - //! _else_ branch. Hence, `_(x)` is always the same as `x`, but the - //! compiler can't tell until the lambda has been called! Hence, the - //! compiler has to wait before it instantiates the body of the lambda - //! and no infinite recursion happens. However, this trick to delay the - //! instantiation of the lambda's body can only be used when the condition - //! is known at compile-time, because otherwise both branches have to be - //! instantiated inside the `eval_if` anyway. - //! - //! There are several caveats to note with this approach to lazy branching. - //! First, because we're using lambdas, it means that the function's - //! result can't be used in a constant expression. This is a limitation - //! of the current language. - //! - //! The second caveat is that compilers currently have several bugs - //! regarding deeply nested lambdas with captures. So you always risk - //! crashing the compiler, but this is a question of time before it is - //! not a problem anymore. - //! - //! Finally, it means that conditionals can't be written directly inside - //! unevaluated contexts. The reason is that a lambda can't appear in an - //! unevaluated context, for example in `decltype`. One way to workaround - //! this is to completely lift your type computations into variable - //! templates instead. For example, instead of writing - //! @code - //! template <typename T> - //! struct pointerize : decltype( - //! hana::eval_if(hana::traits::is_pointer(hana::type_c<T>), - //! [] { return hana::type_c<T>; }, - //! [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); } - //! )) - //! { }; - //! @endcode - //! - //! you could instead write - //! - //! @code - //! template <typename T> - //! auto pointerize_impl(T t) { - //! return hana::eval_if(hana::traits::is_pointer(t), - //! [] { return hana::type_c<T>; }, - //! [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); } - //! ); - //! } - //! - //! template <typename T> - //! using pointerize = decltype(pointerize_impl(hana::type_c<T>)); - //! @endcode - //! - //! > __Note__: This example would actually be implemented more easily - //! > with partial specializations, but my bag of good examples is empty - //! > at the time of writing this. - //! - //! Now, this hoop-jumping only has to be done in one place, because - //! you should use normal function notation everywhere else in your - //! metaprogram to perform type computations. So the syntactic - //! cost is amortized over the whole program. - //! - //! Another way to work around this limitation of the language would be - //! to use `hana::lazy` for the branches. However, this is only suitable - //! when the branches are not too complicated. With `hana::lazy`, you - //! could write the previous example as - //! @code - //! template <typename T> - //! struct pointerize : decltype( - //! hana::eval_if(hana::traits::is_pointer(hana::type_c<T>), - //! hana::make_lazy(hana::type_c<T>), - //! hana::make_lazy(hana::traits::add_pointer)(hana::type_c<T>) - //! )) - //! { }; - //! @endcode - //! - //! - //! @param cond - //! The condition determining which of the two branches is selected. - //! - //! @param then - //! An expression called as `eval(then)` if `cond` is true-valued. - //! - //! @param else_ - //! A function called as `eval(else_)` if `cond` is false-valued. - //! - //! - //! Example - //! ------- - //! @include example/eval_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto eval_if = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct eval_if_impl : eval_if_impl<L, when<true>> { }; - - struct eval_if_t { - template <typename Cond, typename Then, typename Else> - constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const; - }; - - constexpr eval_if_t eval_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EVAL_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/extend.hpp b/contrib/restricted/boost/boost/hana/fwd/extend.hpp deleted file mode 100644 index 65b68d8011..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/extend.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Forward declares `boost::hana::extend`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EXTEND_HPP -#define BOOST_HANA_FWD_EXTEND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Comonadic application of a function to a comonadic value. - //! @ingroup group-Comonad - //! - //! Given a comonadic value and a function accepting a comonadic input, - //! `extend` returns the result of applying the function to that input - //! inside the comonadic context. - //! - //! - //! Signature - //! --------- - //! Given a Comonad `W` and a function of type \f$ W(T) \to U \f$, the - //! signature is - //! \f$ - //! \mathtt{extend} : W(T) \times (W(T) \to U) \to W(U) - //! \f$ - //! - //! @param w - //! A comonadic value to call the function with. - //! - //! @param f - //! A function of signature \f$ W(T) \to U \f$ to be applied to its - //! comonadic argument inside the comonadic context. - //! - //! - //! Example - //! ------- - //! @include example/extend.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto extend = [](auto&& w, auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename W, typename = void> - struct extend_impl : extend_impl<W, when<true>> { }; - - struct extend_t { - template <typename W_, typename F> - constexpr decltype(auto) operator()(W_&& w, F&& f) const; - }; - - constexpr extend_t extend{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EXTEND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/extract.hpp b/contrib/restricted/boost/boost/hana/fwd/extract.hpp deleted file mode 100644 index 1e71727143..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/extract.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Forward declares `boost::hana::extract`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_EXTRACT_HPP -#define BOOST_HANA_FWD_EXTRACT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Extract a value in a given comonadic context. - //! @ingroup group-Comonad - //! - //! Given a value inside a comonadic context, extract it from that - //! context, performing whatever effects are mandated by that context. - //! This can be seen as the dual operation to the `lift` method of the - //! Applicative concept. - //! - //! - //! Signature - //! --------- - //! Given a Comonad `W`, the signature is - //! \f$ - //! \mathtt{extract} : W(T) \to T - //! \f$ - //! - //! @param w - //! The value to be extracted inside a comonadic context. - //! - //! - //! Example - //! ------- - //! @include example/extract.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto extract = [](auto&& w) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename W, typename = void> - struct extract_impl : extract_impl<W, when<true>> { }; - - struct extract_t { - template <typename W_> - constexpr decltype(auto) operator()(W_&& w) const; - }; - - constexpr extract_t extract{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_EXTRACT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/fill.hpp b/contrib/restricted/boost/boost/hana/fwd/fill.hpp deleted file mode 100644 index 6946c6ffd8..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/fill.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::fill`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FILL_HPP -#define BOOST_HANA_FWD_FILL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Replace all the elements of a structure with a fixed value. - //! @ingroup group-Functor - //! - //! - //! Signature - //! --------- - //! Given `F` a Functor, the signature is - //! \f$ - //! \mathtt{fill} : F(T) \times U \to F(U) - //! \f$ - //! - //! @param xs - //! The structure to fill with a `value`. - //! - //! @param value - //! A value by which every element `x` of the structure is replaced, - //! unconditionally. - //! - //! - //! Example - //! ------- - //! @include example/fill.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto fill = [](auto&& xs, auto&& value) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct fill_impl : fill_impl<Xs, when<true>> { }; - - struct fill_t { - template <typename Xs, typename Value> - constexpr auto operator()(Xs&& xs, Value&& value) const; - }; - - constexpr fill_t fill{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FILL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/filter.hpp b/contrib/restricted/boost/boost/hana/fwd/filter.hpp deleted file mode 100644 index f31b30df52..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/filter.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*! -@file -Forward declares `boost::hana::filter`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FILTER_HPP -#define BOOST_HANA_FWD_FILTER_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Filter a monadic structure using a custom predicate. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure and a predicate, `filter` returns a new - //! monadic structure containing only those elements that satisfy the - //! predicate. This is a generalization of the usual `filter` function - //! for sequences; it works for any MonadPlus. Intuitively, `filter` is - //! somewhat equivalent to: - //! @code - //! filter(xs, pred) == flatten(transform(xs, [](auto x) { - //! return pred(x) ? lift<Xs>(x) : empty<Xs>(); - //! }) - //! @endcode - //! In other words, we basically turn a monadic structure containing - //! `[x1, ..., xn]` into a monadic structure containing - //! @code - //! [ - //! pred(x1) ? [x1] : [], - //! pred(x2) ? [x2] : [], - //! ... - //! pred(xn) ? [xn] : [] - //! ] - //! @endcode - //! and we then `flatten` that. - //! - //! - //! Signature - //! --------- - //! Given a `MonadPlus` `M` and an `IntegralConstant` `Bool` holding a - //! value of type `bool`, the signature is - //! @f$ \mathtt{filter} : M(T) \times (T \to \mathtt{Bool}) \to M(T) @f$. - //! - //! @param xs - //! The monadic structure to filter. - //! - //! @param pred - //! A function called as `pred(x)` for each element `x` in the monadic - //! structure and returning whether that element should be __kept__ in - //! the resulting structure. In the current version of the library, the - //! predicate has to return an `IntegralConstant` holding a value - //! convertible to a `bool`. - //! - //! - //! Example - //! ------- - //! @include example/filter.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto filter = [](auto&& xs, auto&& pred) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct filter_impl : filter_impl<M, when<true>> { }; - - struct filter_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr filter_t filter{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FILTER_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/find.hpp b/contrib/restricted/boost/boost/hana/fwd/find.hpp deleted file mode 100644 index cc88d6f239..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/find.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/*! -@file -Forward declares `boost::hana::find`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FIND_HPP -#define BOOST_HANA_FWD_FIND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Finds the value associated to the given key in a structure. - //! @ingroup group-Searchable - //! - //! Given a `key` and a `Searchable` structure, `find` returns the `just` - //! the first value whose key is equal to the given `key`, or `nothing` if - //! there is no such key. Comparison is done with `equal`. `find` satisfies - //! the following: - //! @code - //! find(xs, key) == find_if(xs, equal.to(key)) - //! @endcode - //! - //! - //! @param xs - //! The structure to be searched. - //! - //! @param key - //! A key to be searched for in the structure. The key has to be - //! `Comparable` with the other keys of the structure. In the current - //! version of the library, the comparison of `key` with any other key - //! of the structure must return a compile-time `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/find.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto find = [](auto&& xs, auto const& key) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct find_impl : find_impl<S, when<true>> { }; - - struct find_t { - template <typename Xs, typename Key> - constexpr auto operator()(Xs&& xs, Key const& key) const; - }; - - constexpr find_t find{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FIND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/find_if.hpp b/contrib/restricted/boost/boost/hana/fwd/find_if.hpp deleted file mode 100644 index d6fca44600..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/find_if.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::find_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FIND_IF_HPP -#define BOOST_HANA_FWD_FIND_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Finds the value associated to the first key satisfying a predicate. - //! @ingroup group-Searchable - //! - //! Given a `Searchable` structure `xs` and a predicate `pred`, - //! `find_if(xs, pred)` returns `just` the first element whose key - //! satisfies the predicate, or `nothing` if there is no such element. - //! - //! - //! @param xs - //! The structure to be searched. - //! - //! @param predicate - //! A function called as `predicate(k)`, where `k` is a key of the - //! structure, and returning whether `k` is the key of the element - //! being searched for. In the current version of the library, the - //! predicate has to return an `IntegralConstant` holding a value - //! that can be converted to `bool`. - //! - //! - //! Example - //! ------- - //! @include example/find_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto find_if = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct find_if_impl : find_if_impl<S, when<true>> { }; - - struct find_if_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr find_if_t find_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FIND_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/first.hpp b/contrib/restricted/boost/boost/hana/fwd/first.hpp deleted file mode 100644 index 0a62a8344f..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/first.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/*! -@file -Forward declares `boost::hana::first`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FIRST_HPP -#define BOOST_HANA_FWD_FIRST_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the first element of a pair. - //! @ingroup group-Product - //! - //! Note that if the `Product` actually stores the elements it contains, - //! `hana::first` is required to return a lvalue reference, a lvalue - //! reference to const or a rvalue reference to the first element, where - //! the type of reference must match that of the pair passed to `first`. - //! If the `Product` does not store the elements it contains (i.e. it - //! generates them on demand), this requirement is dropped. - //! - //! - //! Example - //! ------- - //! @include example/first.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto first = [](auto&& product) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename P, typename = void> - struct first_impl : first_impl<P, when<true>> { }; - - struct first_t { - template <typename Pair> - constexpr decltype(auto) operator()(Pair&& pair) const; - }; - - constexpr first_t first{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FIRST_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/flatten.hpp b/contrib/restricted/boost/boost/hana/fwd/flatten.hpp deleted file mode 100644 index f0e319a131..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/flatten.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::flatten`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FLATTEN_HPP -#define BOOST_HANA_FWD_FLATTEN_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Collapse two levels of monadic structure into a single level. - //! @ingroup group-Monad - //! - //! Given a monadic value wrapped into two levels of monad, `flatten` - //! removes one such level. An implementation of `flatten` must satisfy - //! @code - //! flatten(xs) == chain(xs, id) - //! @endcode - //! - //! For `Sequence`s, this simply takes a `Sequence` of `Sequence`s, and - //! returns a (non-recursively) flattened `Sequence`. - //! - //! - //! Signature - //! --------- - //! For a `Monad` `M`, the signature of `flatten` is - //! @f$ - //! \mathtt{flatten} : M(M(T)) \to M(T) - //! @f$ - //! - //! @param xs - //! A value with two levels of monadic structure, which should be - //! collapsed into a single level of structure. - //! - //! - //! Example - //! ------- - //! @include example/flatten.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto flatten = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct flatten_impl : flatten_impl<M, when<true>> { }; - - struct flatten_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr flatten_t flatten{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FLATTEN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/fold.hpp b/contrib/restricted/boost/boost/hana/fwd/fold.hpp deleted file mode 100644 index e060ab1e1e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/fold.hpp +++ /dev/null @@ -1,38 +0,0 @@ -/*! -@file -Forward declares `boost::hana::fold`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FOLD_HPP -#define BOOST_HANA_FWD_FOLD_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/fold_left.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Equivalent to `fold_left`; provided for convenience. - //! @ingroup group-Foldable - //! - //! `fold` is equivalent to `fold_left`. However, it is not tag-dispatched - //! on its own because it is just an alias to `fold_left`. Also note that - //! `fold` can be called with or without an initial state, just like - //! `fold_left`: - //! - //! @code - //! fold(xs, state, f) == fold_left(xs, state, f) - //! fold(xs, f) == fold_left(xs, f) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/fold.cpp - constexpr auto fold = fold_left; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FOLD_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/fold_left.hpp b/contrib/restricted/boost/boost/hana/fwd/fold_left.hpp deleted file mode 100644 index 22dd22d32f..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/fold_left.hpp +++ /dev/null @@ -1,88 +0,0 @@ -/*! -@file -Forward declares `boost::hana::fold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FOLD_LEFT_HPP -#define BOOST_HANA_FWD_FOLD_LEFT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Left-fold of a structure using a binary operation and an optional - //! initial reduction state. - //! @ingroup group-Foldable - //! - //! `fold_left` is a left-associative fold using a binary operation. - //! Given a structure containing `x1, ..., xn`, a function `f` and - //! an optional initial state, `fold_left` applies `f` as follows - //! @code - //! f(... f(f(f(x1, x2), x3), x4) ..., xn) // without state - //! f(... f(f(f(f(state, x1), x2), x3), x4) ..., xn) // with state - //! @endcode - //! - //! When the structure is empty, two things may arise. If an initial - //! state was provided, it is returned as-is. Otherwise, if the no-state - //! version of the function was used, an error is triggered. When the - //! stucture contains a single element and the no-state version of the - //! function was used, that single element is returned as is. - //! - //! - //! Signature - //! --------- - //! Given a `Foldable` `F` and an optional initial state of tag `S`, - //! the signatures for `fold_left` are - //! \f[ - //! \mathtt{fold\_left} : F(T) \times S \times (S \times T \to S) \to S - //! \f] - //! - //! for the variant with an initial state, and - //! \f[ - //! \mathtt{fold\_left} : F(T) \times (T \times T \to T) \to T - //! \f] - //! - //! for the variant without an initial state. - //! - //! @param xs - //! The structure to fold. - //! - //! @param state - //! The initial value used for folding. - //! - //! @param f - //! A binary function called as `f(state, x)`, where `state` is the - //! result accumulated so far and `x` is an element in the structure. - //! For left folds without an initial state, the function is called as - //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. - //! - //! - //! Example - //! ------- - //! @include example/fold_left.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct fold_left_impl : fold_left_impl<T, when<true>> { }; - - struct fold_left_t { - template <typename Xs, typename State, typename F> - constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; - - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; - }; - - constexpr fold_left_t fold_left{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/fold_right.hpp b/contrib/restricted/boost/boost/hana/fwd/fold_right.hpp deleted file mode 100644 index a4305e9c72..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/fold_right.hpp +++ /dev/null @@ -1,92 +0,0 @@ -/*! -@file -Forward declares `boost::hana::fold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FOLD_RIGHT_HPP -#define BOOST_HANA_FWD_FOLD_RIGHT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Right-fold of a structure using a binary operation and an optional - //! initial reduction state. - //! @ingroup group-Foldable - //! - //! `fold_right` is a right-associative fold using a binary operation. - //! Given a structure containing `x1, ..., xn`, a function `f` and - //! an optional initial state, `fold_right` applies `f` as follows - //! @code - //! f(x1, f(x2, f(x3, f(x4, ... f(xn-1, xn) ... )))) // without state - //! f(x1, f(x2, f(x3, f(x4, ... f(xn, state) ... )))) // with state - //! @endcode - //! - //! @note - //! It is worth noting that the order in which the binary function should - //! expect its arguments is reversed from `fold_left`. - //! - //! When the structure is empty, two things may arise. If an initial - //! state was provided, it is returned as-is. Otherwise, if the no-state - //! version of the function was used, an error is triggered. When the - //! stucture contains a single element and the no-state version of the - //! function was used, that single element is returned as is. - //! - //! - //! Signature - //! --------- - //! Given a `Foldable` `F` and an optional initial state of tag `S`, - //! the signatures for `fold_right` are - //! \f[ - //! \mathtt{fold\_right} : F(T) \times S \times (T \times S \to S) \to S - //! \f] - //! - //! for the variant with an initial state, and - //! \f[ - //! \mathtt{fold\_right} : F(T) \times (T \times T \to T) \to T - //! \f] - //! - //! for the variant without an initial state. - //! - //! @param xs - //! The structure to fold. - //! - //! @param state - //! The initial value used for folding. - //! - //! @param f - //! A binary function called as `f(x, state)`, where `state` is the - //! result accumulated so far and `x` is an element in the structure. - //! For right folds without an initial state, the function is called as - //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. - //! - //! - //! Example - //! ------- - //! @include example/fold_right.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct fold_right_impl : fold_right_impl<T, when<true>> { }; - - struct fold_right_t { - template <typename Xs, typename State, typename F> - constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; - - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; - }; - - constexpr fold_right_t fold_right{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/for_each.hpp b/contrib/restricted/boost/boost/hana/fwd/for_each.hpp deleted file mode 100644 index 83daf25418..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/for_each.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Forward declares `boost::hana::for_each`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FOR_EACH_HPP -#define BOOST_HANA_FWD_FOR_EACH_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Perform an action on each element of a foldable, discarding - //! the result each time. - //! @ingroup group-Foldable - //! - //! Iteration is done from left to right, i.e. in the same order as when - //! using `fold_left`. If the structure is not finite, this method will - //! not terminate. - //! - //! - //! @param xs - //! The structure to iterate over. - //! - //! @param f - //! A function called as `f(x)` for each element `x` of the structure. - //! The result of `f(x)`, whatever it is, is ignored. - //! - //! - //! Example - //! ------- - //! @include example/for_each.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto for_each = [](auto&& xs, auto&& f) -> void { - tag-dispatched; - }; -#else - template <typename T, typename = void> - struct for_each_impl : for_each_impl<T, when<true>> { }; - - struct for_each_t { - template <typename Xs, typename F> - constexpr void operator()(Xs&& xs, F&& f) const; - }; - - constexpr for_each_t for_each{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FOR_EACH_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/front.hpp b/contrib/restricted/boost/boost/hana/fwd/front.hpp deleted file mode 100644 index 3ac1602ea4..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/front.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Forward declares `boost::hana::front`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FRONT_HPP -#define BOOST_HANA_FWD_FRONT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the first element of a non-empty iterable. - //! @ingroup group-Iterable - //! - //! Given a non-empty Iterable `xs` with a linearization of `[x1, ..., xN]`, - //! `front(xs)` is equal to `x1`. If `xs` is empty, it is an error to - //! use this function. Equivalently, `front(xs)` must be equivalent to - //! `at_c<0>(xs)`, and that regardless of the value category of `xs` - //! (`front` must respect the reference semantics of `at`). - //! - //! - //! Example - //! ------- - //! @include example/front.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto front = [](auto&& xs) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct front_impl : front_impl<It, when<true>> { }; - - struct front_t { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const; - }; - - constexpr front_t front{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/fuse.hpp b/contrib/restricted/boost/boost/hana/fwd/fuse.hpp deleted file mode 100644 index cecc97c73a..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/fuse.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Forward declares `boost::hana::fuse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_FUSE_HPP -#define BOOST_HANA_FWD_FUSE_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Transform a function taking multiple arguments into a function that - //! can be called with a compile-time `Foldable`. - //! @ingroup group-Foldable - //! - //! - //! This function is provided for convenience as a different way of - //! calling `unpack`. Specifically, `fuse(f)` is a function such that - //! @code - //! fuse(f)(foldable) == unpack(foldable, f) - //! == f(x...) - //! @endcode - //! where `x...` are the elements in the foldable. This function is - //! useful when one wants to create a function that accepts a foldable - //! which is not known yet. - //! - //! @note - //! This function is not tag-dispatched; customize `unpack` instead. - //! - //! - //! Example - //! ------- - //! @include example/fuse.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto fuse = [](auto&& f) { - return [perfect-capture](auto&& xs) -> decltype(auto) { - return unpack(forwarded(xs), forwarded(f)); - }; - }; -#else - struct fuse_t { - template <typename F> - constexpr auto operator()(F&& f) const; - }; - - constexpr fuse_t fuse{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_FUSE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/greater.hpp b/contrib/restricted/boost/boost/hana/fwd/greater.hpp deleted file mode 100644 index 5fcaa4e32d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/greater.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Forward declares `boost::hana::greater`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_GREATER_HPP -#define BOOST_HANA_FWD_GREATER_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_than_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is greater than `y`. - //! @ingroup group-Orderable - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Orderables `A` and `B` with a common - //! embedding, the signature is - //! @f$ \mathrm{greater} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare. - //! - //! - //! Example - //! ------- - //! @include example/greater.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto greater = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct greater_impl : greater_impl<T, U, when<true>> { }; - - struct greater_t : detail::nested_than<greater_t> { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr greater_t greater{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_GREATER_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/greater_equal.hpp b/contrib/restricted/boost/boost/hana/fwd/greater_equal.hpp deleted file mode 100644 index 4b29bfcc96..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/greater_equal.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Forward declares `boost::hana::greater_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_GREATER_EQUAL_HPP -#define BOOST_HANA_FWD_GREATER_EQUAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_than_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is greater than or - //! equal to `y`. - //! @ingroup group-Orderable - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Orderables `A` and `B` with a common - //! embedding, the signature is - //! @f$ \mathrm{greater\_equal} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare. - //! - //! - //! Example - //! ------- - //! @include example/greater_equal.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto greater_equal = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct greater_equal_impl : greater_equal_impl<T, U, when<true>> { }; - - struct greater_equal_t : detail::nested_than<greater_equal_t> { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr greater_equal_t greater_equal{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_GREATER_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/group.hpp b/contrib/restricted/boost/boost/hana/fwd/group.hpp deleted file mode 100644 index 1be1bee386..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/group.hpp +++ /dev/null @@ -1,103 +0,0 @@ -/*! -@file -Forward declares `boost::hana::group`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_GROUP_HPP -#define BOOST_HANA_FWD_GROUP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Group adjacent elements of a sequence that all respect a binary - //! predicate, by default equality. - //! @ingroup group-Sequence - //! - //! Given a _finite_ Sequence and an optional predicate (by default - //! `equal`), `group` returns a sequence of subsequences representing - //! groups of adjacent elements that are "equal" with respect to the - //! predicate. In other words, the groups are such that the predicate is - //! satisfied when it is applied to any two adjacent elements in that - //! group. The sequence returned by `group` is such that the concatenation - //! of its elements is equal to the original sequence, which is equivalent - //! to saying that the order of the elements is not changed. - //! - //! If no predicate is provided, adjacent elements in the sequence must - //! all be compile-time `Comparable`. - //! - //! - //! Signature - //! --------- - //! Given a Sequence `s` with tag `S(T)`, an `IntegralConstant` `Bool` - //! holding a value of type `bool`, and a predicate - //! \f$ pred : T \times T \to Bool \f$, `group` has the following - //! signatures. For the variant with a provided predicate, - //! \f[ - //! \mathtt{group} : S(T) \times (T \times T \to Bool) \to S(S(T)) - //! \f] - //! - //! for the variant without a custom predicate, `T` is required to be - //! Comparable. The signature is then - //! \f[ - //! \mathtt{group} : S(T) \to S(S(T)) - //! \f] - //! - //! @param xs - //! The sequence to split into groups. - //! - //! @param predicate - //! A binary function called as `predicate(x, y)`, where `x` and `y` are - //! _adjacent_ elements in the sequence, whether both elements should be - //! in the same group (subsequence) of the result. In the current version - //! of the library, the result returned by `predicate` must be an - //! `IntegralConstant` holding a value of a type convertible to `bool`. - //! Also, `predicate` has to define an equivalence relation as defined by - //! the `Comparable` concept. When this predicate is not provided, it - //! defaults to `equal`, which requires the comparison of any two adjacent - //! elements in the sequence to return a boolean `IntegralConstant`. - //! - //! - //! Syntactic sugar (`group.by`) - //! ---------------------------- - //! `group` can be called in a third way, which provides a nice syntax - //! especially when working with the `comparing` combinator: - //! @code - //! group.by(predicate, xs) == group(xs, predicate) - //! group.by(predicate) == group(-, predicate) - //! @endcode - //! - //! where `group(-, predicate)` denotes the partial application of - //! `group` to `predicate`. - //! - //! - //! Example - //! ------- - //! @include example/group.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto group = [](auto&& xs[, auto&& predicate]) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct group_impl : group_impl<S, when<true>> { }; - - struct group_t : detail::nested_by<group_t> { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - - template <typename Xs, typename Predicate> - constexpr auto operator()(Xs&& xs, Predicate&& pred) const; - }; - - constexpr group_t group{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_GROUP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/hash.hpp b/contrib/restricted/boost/boost/hana/fwd/hash.hpp deleted file mode 100644 index 38602db518..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/hash.hpp +++ /dev/null @@ -1,68 +0,0 @@ -/*! -@file -Forward declares `boost::hana::hash`. - -@copyright Louis Dionne 2016 -@copyright Jason Rice 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) - */ - -#ifndef BOOST_HANA_FWD_HASH_HPP -#define BOOST_HANA_FWD_HASH_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `hana::type` representing the compile-time hash of an object. - //! @ingroup group-Hashable - //! - //! Given an arbitrary object `x`, `hana::hash` returns a `hana::type` - //! representing the hash of `x`. In normal programming, hashes are - //! usually numerical values that can be used e.g. as indices in an - //! array as part of the implementation of a hash table. In the context - //! of metaprogramming, we are interested in type-level hashes instead. - //! Thus, `hana::hash` must return a `hana::type` object instead of an - //! integer. This `hana::type` must somehow summarize the object being - //! hashed, but that summary may of course lose some information. - //! - //! In order for the `hash` function to be defined properly, it must be - //! the case that whenever `x` is equal to `y`, then `hash(x)` is equal - //! to `hash(y)`. This ensures that `hana::hash` is a function in the - //! mathematical sense of the term. - //! - //! - //! Signature - //! --------- - //! Given a `Hashable` `H`, the signature is - //! \f$ - //! \mathtt{hash} : H \to \mathtt{type\_tag} - //! \f$ - //! - //! @param x - //! An object whose hash is to be computed. - //! - //! - //! Example - //! ------- - //! @include example/hash.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto hash = [](auto const& x) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct hash_impl : hash_impl<T, when<true>> { }; - - struct hash_t { - template <typename X> - constexpr auto operator()(X const& x) const; - }; - - constexpr hash_t hash{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_HASH_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/if.hpp b/contrib/restricted/boost/boost/hana/fwd/if.hpp deleted file mode 100644 index 59b61975f8..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/if.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::if_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_IF_HPP -#define BOOST_HANA_FWD_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Conditionally return one of two values based on a condition. - //! @ingroup group-Logical - //! - //! Specifically, `then` is returned iff `cond` is true-valued, and - //! `else_` is returned otherwise. Note that some `Logical` models may - //! allow `then` and `else_` to have different types, while others may - //! require both values to have the same type. - //! - //! - //! @param cond - //! The condition determining which of the two values is returned. - //! - //! @param then - //! The value returned when `cond` is true-valued. - //! - //! @param else_ - //! The value returned when `cond` is false-valued. - //! - //! - //! Example - //! ------- - //! @include example/if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto if_ = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct if_impl : if_impl<L, when<true>> { }; - - struct if_t { - template <typename Cond, typename Then, typename Else> - constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const; - }; - - constexpr if_t if_{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/index_if.hpp b/contrib/restricted/boost/boost/hana/fwd/index_if.hpp deleted file mode 100644 index 59f98f59fa..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/index_if.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/*! -@file -Forward declares `boost::hana::index_if`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INDEX_IF_HPP -#define BOOST_HANA_FWD_INDEX_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Finds the value associated to the first key satisfying a predicate. - //! @ingroup group-Iterable - //! - //! Given an `Iterable` structure `xs` and a predicate `pred`, - //! `index_if(xs, pred)` returns a `hana::optional` containing an `IntegralConstant` - //! of the index of the first element that satisfies the predicate or nothing - //! if no element satisfies the predicate. - //! - //! - //! @param xs - //! The structure to be searched. - //! - //! @param predicate - //! A function called as `predicate(x)`, where `x` is an element of the - //! `Iterable` structure and returning whether `x` is the element being - //! searched for. In the current version of the library, the predicate - //! has to return an `IntegralConstant` holding a value that can be - //! converted to `bool`. - //! - //! - //! Example - //! ------- - //! @include example/index_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto index_if = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct index_if_impl : index_if_impl<S, when<true>> { }; - - struct index_if_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr index_if_t index_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INDEX_IF_HPP - diff --git a/contrib/restricted/boost/boost/hana/fwd/insert.hpp b/contrib/restricted/boost/boost/hana/fwd/insert.hpp deleted file mode 100644 index 3ca9aa458d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/insert.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/*! -@file -Forward declares `boost::hana::insert`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INSERT_HPP -#define BOOST_HANA_FWD_INSERT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename T, typename = void> - struct insert_impl : insert_impl<T, when<true>> { }; - //! @endcond - - struct insert_t { - template <typename Set, typename ...Args> - constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; - }; - - constexpr insert_t insert{}; - - - //! Insert a value at a given index in a sequence. - //! @ingroup group-Sequence - //! - //! Given a sequence, an index and an element to insert, `insert` inserts - //! the element at the given index. - //! - //! @param xs - //! The sequence in which a value should be inserted. - //! - //! @param n - //! The index at which an element should be inserted. This must be a - //! non-negative `Constant` of an integral type, and it must also be - //! true that `n < length(xs)` if `xs` is a finite sequence. - //! - //! @param element - //! The element to insert in the sequence. - //! - //! - //! Example - //! ------- - //! @include example/insert.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto insert = [](auto&& xs, auto&& n, auto&& element) { - return tag-dispatched; - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INSERT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/insert_range.hpp b/contrib/restricted/boost/boost/hana/fwd/insert_range.hpp deleted file mode 100644 index 88b6d98acd..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/insert_range.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::insert_range`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INSERT_RANGE_HPP -#define BOOST_HANA_FWD_INSERT_RANGE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Insert several values at a given index in a sequence. - //! @ingroup group-Sequence - //! - //! Given a sequence, an index and any `Foldable` containing elements to - //! insert, `insert_range` inserts the elements in the `Foldable` at the - //! given index of the sequence. - //! - //! @param xs - //! The sequence in which values should be inserted. - //! - //! @param n - //! The index at which elements should be inserted. This must be a - //! non-negative `Constant` of an integral type, and it must also be - //! true that `n < length(xs)` if `xs` is a finite sequence. - //! - //! @param elements - //! A `Foldable` containing elements to insert in the sequence. - //! - //! - //! Example - //! ------- - //! @include example/insert_range.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto insert_range = [](auto&& xs, auto&& n, auto&& elements) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct insert_range_impl : insert_range_impl<S, when<true>> { }; - - struct insert_range_t { - template <typename Xs, typename N, typename Elements> - constexpr auto operator()(Xs&& xs, N&& n, Elements&& elements) const; - }; - - constexpr insert_range_t insert_range{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INSERT_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/integral_constant.hpp b/contrib/restricted/boost/boost/hana/fwd/integral_constant.hpp deleted file mode 100644 index 6ef1272d80..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/integral_constant.hpp +++ /dev/null @@ -1,175 +0,0 @@ -/*! -@file -Forward declares `boost::hana::integral_constant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/integral_constant.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Creates an `integral_constant` holding the given compile-time value. - //! @relates hana::integral_constant - //! - //! Specifically, `integral_c<T, v>` is a `hana::integral_constant` - //! holding the compile-time value `v` of an integral type `T`. - //! - //! - //! @tparam T - //! The type of the value to hold in the `integral_constant`. - //! It must be an integral type. - //! - //! @tparam v - //! The integral value to hold in the `integral_constant`. - //! - //! - //! Example - //! ------- - //! @snippet example/integral_constant.cpp integral_c - template <typename T, T v> - constexpr integral_constant<T, v> integral_c{}; - - - //! @relates hana::integral_constant - template <bool b> - using bool_ = integral_constant<bool, b>; - - //! @relates hana::integral_constant - template <bool b> - constexpr bool_<b> bool_c{}; - - //! @relates hana::integral_constant - using true_ = bool_<true>; - - //! @relates hana::integral_constant - constexpr auto true_c = bool_c<true>; - - //! @relates hana::integral_constant - using false_ = bool_<false>; - - //! @relates hana::integral_constant - constexpr auto false_c = bool_c<false>; - - - //! @relates hana::integral_constant - template <char c> - using char_ = integral_constant<char, c>; - - //! @relates hana::integral_constant - template <char c> - constexpr char_<c> char_c{}; - - - //! @relates hana::integral_constant - template <short i> - using short_ = integral_constant<short, i>; - - //! @relates hana::integral_constant - template <short i> - constexpr short_<i> short_c{}; - - - //! @relates hana::integral_constant - template <unsigned short i> - using ushort_ = integral_constant<unsigned short, i>; - - //! @relates hana::integral_constant - template <unsigned short i> - constexpr ushort_<i> ushort_c{}; - - - //! @relates hana::integral_constant - template <int i> - using int_ = integral_constant<int, i>; - - //! @relates hana::integral_constant - template <int i> - constexpr int_<i> int_c{}; - - - //! @relates hana::integral_constant - template <unsigned int i> - using uint = integral_constant<unsigned int, i>; - - //! @relates hana::integral_constant - template <unsigned int i> - constexpr uint<i> uint_c{}; - - - //! @relates hana::integral_constant - template <long i> - using long_ = integral_constant<long, i>; - - //! @relates hana::integral_constant - template <long i> - constexpr long_<i> long_c{}; - - - //! @relates hana::integral_constant - template <unsigned long i> - using ulong = integral_constant<unsigned long, i>; - - //! @relates hana::integral_constant - template <unsigned long i> - constexpr ulong<i> ulong_c{}; - - - //! @relates hana::integral_constant - template <long long i> - using llong = integral_constant<long long, i>; - - //! @relates hana::integral_constant - template <long long i> - constexpr llong<i> llong_c{}; - - - //! @relates hana::integral_constant - template <unsigned long long i> - using ullong = integral_constant<unsigned long long, i>; - - //! @relates hana::integral_constant - template <unsigned long long i> - constexpr ullong<i> ullong_c{}; - - - //! @relates hana::integral_constant - template <std::size_t i> - using size_t = integral_constant<std::size_t, i>; - - //! @relates hana::integral_constant - template <std::size_t i> - constexpr size_t<i> size_c{}; - - - namespace literals { - //! Creates a `hana::integral_constant` from a literal. - //! @relatesalso boost::hana::integral_constant - //! - //! The literal is parsed at compile-time and the result is returned - //! as a `llong<...>`. - //! - //! @note - //! We use `llong<...>` instead of `ullong<...>` because using an - //! unsigned type leads to unexpected behavior when doing stuff like - //! `-1_c`. If we used an unsigned type, `-1_c` would be something - //! like `ullong<-1>` which is actually `ullong<something huge>`. - //! - //! - //! Example - //! ------- - //! @snippet example/integral_constant.cpp literals - template <char ...c> - constexpr auto operator"" _c(); - } -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/intersection.hpp b/contrib/restricted/boost/boost/hana/fwd/intersection.hpp deleted file mode 100644 index f289dd03fa..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/intersection.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Forward declares `boost::hana::intersection`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INTERSECTION_HPP -#define BOOST_HANA_FWD_INTERSECTION_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename S, typename = void> - struct intersection_impl : intersection_impl<S, when<true>> { }; - //! @endcond - - struct intersection_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&&, Ys&&) const; - }; - - constexpr intersection_t intersection{}; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INTERSECTION_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/intersperse.hpp b/contrib/restricted/boost/boost/hana/fwd/intersperse.hpp deleted file mode 100644 index 35e8a725b5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/intersperse.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::intersperse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_INTERSPERSE_HPP -#define BOOST_HANA_FWD_INTERSPERSE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Insert a value between each pair of elements in a finite sequence. - //! @ingroup group-Sequence - //! - //! Given a finite `Sequence` `xs` with a linearization of - //! `[x1, x2, ..., xn]`, `intersperse(xs, z)` is a new sequence with a - //! linearization of `[x1, z, x2, z, x3, ..., xn-1, z, xn]`. In other - //! words, it inserts the `z` element between every pair of elements of - //! the original sequence. If the sequence is empty or has a single - //! element, `intersperse` returns the sequence as-is. In all cases, - //! the sequence must be finite. - //! - //! - //! @param xs - //! The sequence in which a value is interspersed. - //! - //! @param z - //! The value to be inserted between every pair of elements of the sequence. - //! - //! - //! Example - //! ------- - //! @include example/intersperse.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto intersperse = [](auto&& xs, auto&& z) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct intersperse_impl : intersperse_impl<S, when<true>> { }; - - struct intersperse_t { - template <typename Xs, typename Z> - constexpr auto operator()(Xs&& xs, Z&& z) const; - }; - - constexpr intersperse_t intersperse{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_INTERSPERSE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/is_disjoint.hpp b/contrib/restricted/boost/boost/hana/fwd/is_disjoint.hpp deleted file mode 100644 index 8a3520b558..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/is_disjoint.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Forward declares `boost::hana::is_disjoint`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_IS_DISJOINT_HPP -#define BOOST_HANA_FWD_IS_DISJOINT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether two `Searchable`s are disjoint. - //! @ingroup group-Searchable - //! - //! Given two `Searchable`s `xs` and `ys`, `is_disjoint` returns a - //! `Logical` representing whether the keys in `xs` are disjoint from - //! the keys in `ys`, i.e. whether both structures have no keys in common. - //! - //! - //! @param xs, ys - //! Two `Searchable`s to test for disjointness. - //! - //! - //! Example - //! ------- - //! @include example/is_disjoint.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_disjoint = [](auto const& xs, auto const& ys) { - return tag-dispatched; - }; -#else - template <typename S1, typename S2, typename = void> - struct is_disjoint_impl : is_disjoint_impl<S1, S2, when<true>> { }; - - struct is_disjoint_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&& xs, Ys&& ys) const; - }; - - constexpr is_disjoint_t is_disjoint{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_IS_DISJOINT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/is_empty.hpp b/contrib/restricted/boost/boost/hana/fwd/is_empty.hpp deleted file mode 100644 index a33dc5af8c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/is_empty.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/*! -@file -Forward declares `boost::hana::is_empty`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_IS_EMPTY_HPP -#define BOOST_HANA_FWD_IS_EMPTY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether the iterable is empty. - //! @ingroup group-Iterable - //! - //! Given an `Iterable` `xs`, `is_empty` returns whether `xs` contains - //! no more elements. In other words, it returns whether trying to - //! extract the tail of `xs` would be an error. In the current version - //! of the library, `is_empty` must return an `IntegralConstant` holding - //! a value convertible to `bool`. This is because only compile-time - //! `Iterable`s are supported right now. - //! - //! - //! Example - //! ------- - //! @include example/is_empty.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_empty = [](auto const& xs) { - return tag-dispatched; - }; -#else - template <typename It, typename = void> - struct is_empty_impl : is_empty_impl<It, when<true>> { }; - - struct is_empty_t { - template <typename Xs> - constexpr auto operator()(Xs const& xs) const; - }; - - constexpr is_empty_t is_empty{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_IS_EMPTY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/is_subset.hpp b/contrib/restricted/boost/boost/hana/fwd/is_subset.hpp deleted file mode 100644 index aceb85aa86..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/is_subset.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/*! -@file -Forward declares `boost::hana::is_subset`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_IS_SUBSET_HPP -#define BOOST_HANA_FWD_IS_SUBSET_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <boost/hana/functional/infix.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether a structure contains a subset of the keys of - //! another structure. - //! @ingroup group-Searchable - //! - //! Given two `Searchable`s `xs` and `ys`, `is_subset` returns a `Logical` - //! representing whether `xs` is a subset of `ys`. In other words, it - //! returns whether all the keys of `xs` are also present in `ys`. This - //! method does not return whether `xs` is a _strict_ subset of `ys`; if - //! `xs` and `ys` are equal, all the keys of `xs` are also present in - //! `ys`, and `is_subset` returns true. - //! - //! @note - //! For convenience, `is_subset` can also be applied in infix notation. - //! - //! - //! Cross-type version of the method - //! -------------------------------- - //! This method is tag-dispatched using the tags of both arguments. - //! It can be called with any two `Searchable`s sharing a common - //! `Searchable` embedding, as defined in the main documentation - //! of the `Searchable` concept. When `Searchable`s with two different - //! tags but sharing a common embedding are sent to `is_subset`, they - //! are first converted to this common `Searchable` and the `is_subset` - //! method of the common embedding is then used. Of course, the method - //! can be overriden for custom `Searchable`s for efficieny. - //! - //! @note - //! While cross-type dispatching for `is_subset` is supported, it is - //! not currently used by the library because there are no models - //! of `Searchable` with a common embedding. - //! - //! - //! @param xs - //! The structure to check whether it is a subset of `ys`. - //! - //! @param ys - //! The structure to check whether it is a superset of `xs`. - //! - //! - //! Example - //! ------- - //! @include example/is_subset.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_subset = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#else - template <typename S1, typename S2, typename = void> - struct is_subset_impl : is_subset_impl<S1, S2, when<true>> { }; - - struct is_subset_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&& xs, Ys&& ys) const; - }; - - constexpr auto is_subset = hana::infix(is_subset_t{}); -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_IS_SUBSET_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/keys.hpp b/contrib/restricted/boost/boost/hana/fwd/keys.hpp deleted file mode 100644 index 24c93b749a..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/keys.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Forward declares `boost::hana::keys`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_KEYS_HPP -#define BOOST_HANA_FWD_KEYS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename T, typename = void> - struct keys_impl : keys_impl<T, when<true>> { }; - //! @endcond - - struct keys_t { - template <typename Map> - constexpr auto operator()(Map&& map) const; - }; - - constexpr keys_t keys{}; - - //! Returns a `Sequence` containing the name of the members of - //! the data structure. - //! @ingroup group-Struct - //! - //! Given a `Struct` object, `keys` returns a `Sequence` containing the - //! name of all the members of the `Struct`, in the same order as they - //! appear in the `accessors` sequence. - //! - //! - //! Example - //! ------- - //! @include example/struct/keys.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto keys = [](auto&& object) { - return implementation_defined; - }; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_KEYS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/lazy.hpp b/contrib/restricted/boost/boost/hana/fwd/lazy.hpp deleted file mode 100644 index 7568e8e4a6..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/lazy.hpp +++ /dev/null @@ -1,124 +0,0 @@ -/*! -@file -Forward declares `boost::hana::lazy`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LAZY_HPP -#define BOOST_HANA_FWD_LAZY_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! `hana::lazy` implements superficial laziness via a monadic interface. - //! - //! It is important to understand that the laziness implemented by `lazy` - //! is only superficial; only function applications made inside the `lazy` - //! monad can be made lazy, not all their subexpressions. - //! - //! - //! @note - //! The actual representation of `hana::lazy` is completely - //! implementation-defined. Lazy values may only be created through - //! `hana::make_lazy`, and they can be stored in variables using - //! `auto`, but any other assumption about the representation of - //! `hana::lazy<...>` should be avoided. In particular, one should - //! not rely on the fact that `hana::lazy<...>` can be pattern-matched - //! on, because it may be a dependent type. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Functor`\n - //! Applying a function over a lazy value with `transform` returns the - //! result of applying the function, as a lazy value. - //! @include example/lazy/functor.cpp - //! - //! 2. `Applicative`\n - //! A normal value can be lifted into a lazy value by using `lift<lazy_tag>`. - //! A lazy function can be lazily applied to a lazy value by using `ap`. - //! - //! 3. `Monad`\n - //! The `lazy` monad allows combining lazy computations into larger - //! lazy computations. Note that the `|` operator can be used in place - //! of the `chain` function. - //! @include example/lazy/monad.cpp - //! - //! 4. `Comonad`\n - //! The `lazy` comonad allows evaluating a lazy computation to get its - //! result and lazily applying functions taking lazy inputs to lazy - //! values. This [blog post][1] goes into more details about lazy - //! evaluation and comonads. - //! @include example/lazy/comonad.cpp - //! - //! - //! @note - //! `hana::lazy` only models a few concepts because providing more - //! functionality would require evaluating the lazy values in most cases. - //! Since this raises some issues such as side effects and memoization, - //! the interface is kept minimal. - //! - //! - //! [1]: http://ldionne.com/2015/03/16/laziness-as-a-comonad -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename implementation_defined> - struct lazy { - //! Equivalent to `hana::chain`. - template <typename ...T, typename F> - friend constexpr auto operator|(lazy<T...>, F); - }; -#else - // We do not _actually_ define the lazy<...> type. Per the documentation, - // users can't rely on it being anything, and so they should never use - // it explicitly. The implementation in <boost/hana/lazy.hpp> is much - // simpler if we use different types for lazy calls and lazy values. -#endif - - //! Tag representing `hana::lazy`. - //! @relates hana::lazy - struct lazy_tag { }; - - //! Lifts a normal value to a lazy one. - //! @relates hana::lazy - //! - //! `make<lazy_tag>` can be used to lift a normal value or a function call - //! into a lazy expression. Precisely, `make<lazy_tag>(x)` is a lazy value - //! equal to `x`, and `make<lazy_tag>(f)(x1, ..., xN)` is a lazy function - //! call that is equal to `f(x1, ..., xN)` when it is `eval`uated. - //! - //! @note - //! It is interesting to note that `make<lazy_tag>(f)(x1, ..., xN)` is - //! equivalent to - //! @code - //! ap(make<lazy_tag>(f), lift<lazy_tag>(x1), ..., lift<lazy_tag>(xN)) - //! @endcode - //! which in turn is equivalent to `make<lazy_tag>(f(x1, ..., xN))`, except - //! for the fact that the inner call to `f` is evaluated lazily. - //! - //! - //! Example - //! ------- - //! @include example/lazy/make.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <> - constexpr auto make<lazy_tag> = [](auto&& x) { - return lazy<implementation_defined>{forwarded(x)}; - }; -#endif - - //! Alias to `make<lazy_tag>`; provided for convenience. - //! @relates hana::lazy - //! - //! Example - //! ------- - //! @include example/lazy/make.cpp - constexpr auto make_lazy = make<lazy_tag>; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LAZY_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/length.hpp b/contrib/restricted/boost/boost/hana/fwd/length.hpp deleted file mode 100644 index 331b1d93d2..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/length.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Forward declares `boost::hana::length`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LENGTH_HPP -#define BOOST_HANA_FWD_LENGTH_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the number of elements in a foldable structure. - //! @ingroup group-Foldable - //! - //! Given a `Foldable` `xs`, `length(xs)` must return an object of an - //! unsigned integral type, or an `IntegralConstant` holding such an - //! object, which represents the number of elements in the structure. - //! - //! @note - //! Since only compile-time `Foldable`s are supported in the library - //! right now, `length` must always return an `IntegralConstant`. - //! - //! - //! Example - //! ------- - //! @include example/length.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto length = [](auto const& xs) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct length_impl : length_impl<T, when<true>> { }; - - struct length_t { - template <typename Xs> - constexpr auto operator()(Xs const& xs) const; - }; - - constexpr length_t length{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LENGTH_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/less.hpp b/contrib/restricted/boost/boost/hana/fwd/less.hpp deleted file mode 100644 index f1695b2b74..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/less.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Forward declares `boost::hana::less`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LESS_HPP -#define BOOST_HANA_FWD_LESS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_than_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is less than `y`. - //! @ingroup group-Orderable - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Orderables `A` and `B` with a common - //! embedding, the signature is - //! @f$ \mathrm{less} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare. - //! - //! - //! Example - //! ------- - //! @include example/less.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto less = [](auto&& x, auto&& y) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct less_impl : less_impl<T, U, when<true>> { }; - - struct less_t : detail::nested_than<less_t> { - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) const; - }; - - constexpr less_t less{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LESS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/less_equal.hpp b/contrib/restricted/boost/boost/hana/fwd/less_equal.hpp deleted file mode 100644 index e5c66e4bc3..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/less_equal.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Forward declares `boost::hana::less_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LESS_EQUAL_HPP -#define BOOST_HANA_FWD_LESS_EQUAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_than_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is less than or - //! equal to `y`. - //! @ingroup group-Orderable - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Orderables `A` and `B` with a common - //! embedding, the signature is - //! @f$ \mathrm{less\_equal} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare. - //! - //! - //! Example - //! ------- - //! @include example/less_equal.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto less_equal = [](auto&& x, auto&& y) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct less_equal_impl : less_equal_impl<T, U, when<true>> { }; - - struct less_equal_t : detail::nested_than<less_equal_t> { - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) const; - }; - - constexpr less_equal_t less_equal{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LESS_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/lexicographical_compare.hpp b/contrib/restricted/boost/boost/hana/fwd/lexicographical_compare.hpp deleted file mode 100644 index a95aac5212..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/lexicographical_compare.hpp +++ /dev/null @@ -1,93 +0,0 @@ -/*! -@file -Forward declares `boost::hana::lexicographical_compare`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP -#define BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Short-circuiting lexicographical comparison of two `Iterable`s with - //! an optional custom predicate, by default `hana::less`. - //! @ingroup group-Iterable - //! - //! Given two `Iterable`s `xs` and `ys` and a binary predicate `pred`, - //! `lexicographical_compare` returns whether `xs` is to be considered - //! less than `ys` in a lexicographical ordering. Specifically, let's - //! denote the linearizations of `xs` and `ys` by `[x1, x2, ...]` and - //! `[y1, y2, ...]`, respectively. If the first couple satisfying the - //! predicate is of the form `xi, yi`, `lexicographical_compare` returns - //! true. Otherwise, if the first couple to satisfy the predicate is of - //! the form `yi, xi`, `lexicographical_compare` returns false. If no - //! such couple can be found, `lexicographical_compare` returns whether - //! `xs` has fewer elements than `ys`. - //! - //! @note - //! This algorithm will short-circuit as soon as it can determine that one - //! sequence is lexicographically less than the other. Hence, it can be - //! used to compare infinite sequences. However, for the procedure to - //! terminate on infinite sequences, the predicate has to be satisfied - //! at a finite index. - //! - //! - //! Signature - //! --------- - //! Given two `Iterable`s `It1(T)` and `It2(T)` and a predicate - //! \f$ pred : T \times T \to Bool \f$ (where `Bool` is some `Logical`), - //! `lexicographical_compare` has the following signatures. For the - //! variant with a provided predicate, - //! \f[ - //! \mathtt{lexicographical\_compare} - //! : It1(T) \times It2(T) \times (T \times T \to Bool) \to Bool - //! \f] - //! - //! for the variant without a custom predicate, `T` is required to be - //! `Orderable`. The signature is then - //! \f[ - //! \mathtt{lexicographical\_compare} : It1(T) \times It2(T) \to Bool - //! \f] - //! - //! @param xs, ys - //! Two `Iterable`s to compare lexicographically. - //! - //! @param pred - //! A binary function called as `pred(x, y)` and `pred(y, x)`, where `x` - //! and `y` are elements of `xs` and `ys`, respectively. `pred` must - //! return a `Logical` representing whether its first argument is to be - //! considered as less than its second argument. Also note that `pred` - //! must define a total ordering as defined by the `Orderable` concept. - //! When `pred` is not provided, it defaults to `less`. - //! - //! - //! Example - //! ------- - //! @include example/lexicographical_compare.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto lexicographical_compare = [](auto const& xs, auto const& ys, auto const& pred = hana::less) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct lexicographical_compare_impl : lexicographical_compare_impl<T, when<true>> { }; - - struct lexicographical_compare_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs const& xs, Ys const& ys) const; - - template <typename Xs, typename Ys, typename Pred> - constexpr auto operator()(Xs const& xs, Ys const& ys, Pred const& pred) const; - }; - - constexpr lexicographical_compare_t lexicographical_compare{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/lift.hpp b/contrib/restricted/boost/boost/hana/fwd/lift.hpp deleted file mode 100644 index 9491dab8a4..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/lift.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/*! -@file -Forward declares `boost::hana::lift`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_LIFT_HPP -#define BOOST_HANA_FWD_LIFT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Lift a value into an `Applicative` structure. - //! @ingroup group-Applicative - //! - //! `lift<A>` takes a normal value and embeds it into a structure whose - //! shape is represented by the `A` `Applicative`. Note that the value - //! may be a function, in which case the created structure may be - //! `ap`plied to another `Applicative` structure containing values. - //! - //! - //! Signature - //! --------- - //! Given an Applicative `A`, the signature is - //! @f$ \mathtt{lift}_A : T \to A(T) @f$. - //! - //! @tparam A - //! A tag representing the `Applicative` into which the value is lifted. - //! - //! @param x - //! The value to lift into the applicative. - //! - //! - //! Example - //! ------- - //! @include example/lift.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename A> - constexpr auto lift = [](auto&& x) { - return tag-dispatched; - }; -#else - template <typename A, typename = void> - struct lift_impl : lift_impl<A, when<true>> { }; - - template <typename A> - struct lift_t; - - template <typename A> - constexpr lift_t<A> lift{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_LIFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/map.hpp b/contrib/restricted/boost/boost/hana/fwd/map.hpp deleted file mode 100644 index c00f57195f..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/map.hpp +++ /dev/null @@ -1,380 +0,0 @@ -/*! -@file -Forward declares `boost::hana::map`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MAP_HPP -#define BOOST_HANA_FWD_MAP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/erase_key.hpp> -#include <boost/hana/fwd/insert.hpp> -#include <boost/hana/fwd/keys.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Tag representing `hana::map`s. - //! @relates hana::map - struct map_tag { }; - - namespace detail { - template <typename ...Pairs> - struct make_map_type; - } - - //! @ingroup group-datatypes - //! Basic associative container requiring unique, `Comparable` and - //! `Hashable` keys. - //! - //! The order of the elements of the map is unspecified. Also, all the - //! keys must be `Hashable`, and any two keys with equal hashes must be - //! `Comparable` with each other at compile-time. - //! - //! Note that the actual representation of a `hana::map` is an implementation - //! detail. As such, one should not assume anything more than what is - //! explicitly documented as being part of the interface of a map, - //! such as: - //! - the presence of additional constructors - //! - the presence of additional assignment operators - //! - the fact that `hana::map<Pairs...>` is, or is not, a dependent type - //! - //! In particular, the last point is very important; `hana::map<Pairs...>` - //! is basically equivalent to - //! @code - //! decltype(hana::make_pair(std::declval<Pairs>()...)) - //! @endcode - //! which is not something that can be pattern-matched on during template - //! argument deduction, for example. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two maps are equal iff all their keys are equal and are associated - //! to equal values. - //! @include example/map/comparable.cpp - //! - //! 2. `Searchable`\n - //! A map can be searched by its keys with a predicate yielding a - //! compile-time `Logical`. Also note that `operator[]` can be used - //! instead of `at_key`. - //! @include example/map/searchable.cpp - //! - //! 3. `Foldable`\n - //! Folding a map is equivalent to folding a list of the key/value pairs - //! it contains. In particular, since that list is not guaranteed to be - //! in any specific order, folding a map with an operation that is not - //! both commutative and associative will yield non-deterministic behavior. - //! @include example/map/foldable.cpp - //! - //! - //! Conversion from any `Foldable` - //! ------------------------------ - //! Any `Foldable` of `Product`s can be converted to a `hana::map` with - //! `hana::to<hana::map_tag>` or, equivalently, `hana::to_map`. If the - //! `Foldable` contains duplicate keys, only the value associated to the - //! first occurence of each key is kept. - //! @include example/map/to.cpp - //! - //! - //! Example - //! ------- - //! @include example/map/map.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename ...Pairs> - struct map { - //! Default-construct a map. This constructor only exists when all the - //! elements of the map are default-constructible. - constexpr map() = default; - - //! Copy-construct a map from another map. This constructor only - //! exists when all the elements of the map are copy-constructible. - constexpr map(map const& other) = default; - - //! Move-construct a map from another map. This constructor only - //! exists when all the elements of the map are move-constructible. - constexpr map(map&& other) = default; - - //! Construct the map from the provided pairs. `P...` must be pairs of - //! the same type (modulo ref and cv-qualifiers), and in the same order, - //! as those appearing in `Pairs...`. The pairs provided to this - //! constructor are emplaced into the map's storage using perfect - //! forwarding. - template <typename ...P> - explicit constexpr map(P&& ...pairs); - - //! Assign a map to another map __with the exact same type__. Only - //! exists when all the elements of the map are copy-assignable. - constexpr map& operator=(map const& other); - - //! Move-assign a map to another map __with the exact same type__. - //! Only exists when all the elements of the map are move-assignable. - constexpr map& operator=(map&& other); - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::at_key` - template <typename Key> - constexpr decltype(auto) operator[](Key&& key); - }; -#else - template <typename ...Pairs> - using map = typename detail::make_map_type<Pairs...>::type; -#endif - - //! Function object for creating a `hana::map`. - //! @relates hana::map - //! - //! Given zero or more `Product`s representing key/value associations, - //! `make<map_tag>` returns a `hana::map` associating these keys to these - //! values. - //! - //! `make<map_tag>` requires all the keys to be unique and to have - //! different hashes. If you need to create a map with duplicate keys - //! or with keys whose hashes might collide, use `hana::to_map` or - //! insert `(key, value)` pairs to an empty map successively. However, - //! be aware that doing so will be much more compile-time intensive than - //! using `make<map_tag>`, because the uniqueness of keys will have to be - //! enforced. - //! - //! - //! Example - //! ------- - //! @include example/map/make.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <> - constexpr auto make<map_tag> = [](auto&& ...pairs) { - return map<implementation_defined>{forwarded(pairs)...}; - }; -#endif - - //! Alias to `make<map_tag>`; provided for convenience. - //! @relates hana::map - //! - //! - //! Example - //! ------- - //! @include example/map/make.cpp - constexpr auto make_map = make<map_tag>; - - //! Equivalent to `to<map_tag>`; provided for convenience. - //! @relates hana::map - constexpr auto to_map = to<map_tag>; - - //! Returns a `Sequence` of the keys of the map, in unspecified order. - //! @relates hana::map - //! - //! - //! Example - //! ------- - //! @include example/map/keys.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto keys = [](auto&& map) { - return implementation_defined; - }; -#endif - - //! Returns a `Sequence` of the values of the map, in unspecified order. - //! @relates hana::map - //! - //! - //! Example - //! ------- - //! @include example/map/values.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto values = [](auto&& map) -> decltype(auto) { - return implementation_defined; - }; -#else - struct values_t { - template <typename Map> - constexpr decltype(auto) operator()(Map&& map) const; - }; - - constexpr values_t values{}; -#endif - - //! Inserts a new key/value pair in a map. - //! @relates hana::map - //! - //! Given a `(key, value)` pair, `insert` inserts this new pair into a - //! map. If the map already contains this key, nothing is done and the - //! map is returned as-is. - //! - //! - //! @param map - //! The map in which to insert a `(key,value)` pair. - //! - //! @param pair - //! An arbitrary `Product` representing a `(key, value)` pair to insert - //! in the map. The `key` must be compile-time `Comparable`. - //! - //! - //! Example - //! ------- - //! @include example/map/insert.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto insert = [](auto&& map, auto&& pair) { - return tag-dispatched; - }; -#endif - - //! Removes a key/value pair from a map. - //! @relates hana::map - //! - //! Returns a new `hana::map` containing all the elements of the original, - //! except for the `(key, value)` pair whose `key` compares `equal` - //! to the given key. If the map does not contain such an element, - //! a new map equal to the original is returned. - //! - //! - //! @param map - //! The map in which to erase a `key`. - //! - //! @param key - //! A key to remove from the map. It must be compile-time `Comparable`. - //! - //! - //! Example - //! ------- - //! @include example/map/erase_key.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto erase_key = [](auto&& map, auto&& key) { - return tag-dispatched; - }; -#endif - - //! Returns the union of two maps. - //! @relates hana::map - //! - //! Given two maps `xs` and `ys`, `hana::union_(xs, ys)` is a new map - //! containing all the elements of `xs` and all the elements of `ys`, - //! without duplicates. If both `xs` and `ys` contain an element with the - //! same `key`, the one in `ys` is taken. Functionally, - //! `hana::union_(xs, ys)` is equivalent to - //! @code - //! hana::fold_left(xs, ys, hana::insert) - //! @endcode - //! - //! @param xs, ys - //! The two maps to compute the union of. - //! - //! - //! Example - //! ------- - //! @include example/map/union.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto union_ = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - //! Returns the intersection of two maps. - //! @relates hana::map - //! - //! Given two maps `xs` and `ys`, `intersection(xs, ys)` is a new map - //! containing exactly those (key, value) pairs from xs, for which key - //! is present in `ys`. - //! In other words, the following holds for any object `pair(k, v)`: - //! @code - //! pair(k, v) ^in^ intersection(xs, ys) if and only if (k, v) ^in^ xs && k ^in^ keys(ys) - //! @endcode - //! - //! - //! @note - //! This function is not commutative, i.e. `intersection(xs, ys)` is not - //! necessarily the same as `intersection(ys, xs)`. Indeed, the set of keys - //! in `intersection(xs, ys)` is always the same as the set of keys in - //! `intersection(ys, xs)`, but the value associated to each key may be - //! different. `intersection(xs, ys)` contains values present in `xs`, and - //! `intersection(ys, xs)` contains values present in `ys`. - //! - //! - //! @param xs, ys - //! Two maps to intersect. - //! - //! - //! Example - //! ------- - //! @include example/map/intersection.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto intersection = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - //! Returns the difference of two maps. - //! @relates hana::map - //! - //! Given two maps `xs` and `ys`, `difference(xs, ys)` is a new map - //! containing exactly those (key, value) pairs from xs, for which key - //! is not present in `keys(ys)`. - //! In other words, the following holds for any object `pair(k, v)`: - //! @code - //! pair(k, v) ^in^ difference(xs, ys) if and only if (k, v) ^in^ xs && k ^not in^ keys(ys) - //! @endcode - //! - //! - //! @note - //! This function is not commutative, i.e. `difference(xs, ys)` is not - //! necessarily the same as `difference(ys, xs)`. - //! Indeed, consider the case where `xs` is empty and `ys` isn't. - //! In that case, `difference(xs, ys)` is empty, but `difference(ys, xs)` - //! is equal to `ys`. - //! For symmetric version of this operation, see `symmetric_difference`. - //! - //! - //! @param xs, ys - //! Two maps to compute the difference of. - //! - //! - //! Example - //! ------- - //! @include example/map/intersection.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto difference = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - //! Returns the symmetric set-theoretic difference of two maps. - //! @relates hana::map - //! - //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new - //! map containing all the elements of `xs` whose keys are not contained in `keys(ys)`, - //! and all the elements of `ys` whose keys are not contained in `keys(xs)`. The - //! symmetric difference of two maps satisfies the following: - //! @code - //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) - //! @endcode - //! - //! - //! @param xs, ys - //! Two maps to compute the symmetric difference of. - //! - //! - //! Example - //! ------- - //! @include example/map/symmetric_difference.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED -constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MAP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/max.hpp b/contrib/restricted/boost/boost/hana/fwd/max.hpp deleted file mode 100644 index e34d558e25..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/max.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*! -@file -Forward declares `boost::hana::max`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MAX_HPP -#define BOOST_HANA_FWD_MAX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the greatest of its arguments according to the `less` ordering. - //! @ingroup group-Orderable - //! - //! - //! @todo Can't specify the signature here either. See `min` for details. - //! - //! Example - //! ------- - //! @include example/max.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto max = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct max_impl : max_impl<T, U, when<true>> { }; - - struct max_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr max_t max{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MAX_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/maximum.hpp b/contrib/restricted/boost/boost/hana/fwd/maximum.hpp deleted file mode 100644 index 9a49e83d40..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/maximum.hpp +++ /dev/null @@ -1,116 +0,0 @@ -/*! -@file -Forward declares `boost::hana::maximum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MAXIMUM_HPP -#define BOOST_HANA_FWD_MAXIMUM_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the greatest element of a non-empty structure with respect to - //! a `predicate`, by default `less`. - //! @ingroup group-Foldable - //! - //! Given a non-empty structure and an optional binary predicate - //! (`less` by default), `maximum` returns the greatest element of - //! the structure, i.e. an element which is greater than or equal to - //! every other element in the structure, according to the predicate. - //! - //! If the structure contains heterogeneous objects, then the predicate - //! must return a compile-time `Logical`. If no predicate is provided, - //! the elements in the structure must be Orderable, or compile-time - //! Orderable if the structure is heterogeneous. - //! - //! - //! Signature - //! --------- - //! Given a Foldable `F`, a Logical `Bool` and a predicate - //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `maximum` has the - //! following signatures. For the variant with a provided predicate, - //! \f[ - //! \mathtt{maximum} : F(T) \times (T \times T \to Bool) \to T - //! \f] - //! - //! for the variant without a custom predicate, `T` is required to be - //! Orderable. The signature is then - //! \f[ - //! \mathtt{maximum} : F(T) \to T - //! \f] - //! - //! @param xs - //! The structure to find the greatest element of. - //! - //! @param predicate - //! A function called as `predicate(x, y)`, where `x` and `y` are elements - //! of the structure. `predicate` should be a strict weak ordering on the - //! elements of the structure and its return value should be a Logical, - //! or a compile-time Logical if the structure is heterogeneous. - //! - //! ### Example - //! @include example/maximum.cpp - //! - //! - //! Syntactic sugar (`maximum.by`) - //! ------------------------------ - //! `maximum` can be called in a third way, which provides a nice syntax - //! especially when working with the `ordering` combinator: - //! @code - //! maximum.by(predicate, xs) == maximum(xs, predicate) - //! maximum.by(predicate) == maximum(-, predicate) - //! @endcode - //! - //! where `maximum(-, predicate)` denotes the partial application of - //! `maximum` to `predicate`. - //! - //! ### Example - //! @include example/maximum_by.cpp - //! - //! - //! Tag dispatching - //! --------------- - //! Both the non-predicated version and the predicated versions of - //! `maximum` are tag-dispatched methods, and hence they can be - //! customized independently. One reason for this is that some - //! structures are able to provide a much more efficient implementation - //! of `maximum` when the `less` predicate is used. Here is how the - //! different versions of `maximum` are dispatched: - //! @code - //! maximum(xs) -> maximum_impl<tag of xs>::apply(xs) - //! maximum(xs, pred) -> maximum_pred_impl<tag of xs>::apply(xs, pred) - //! @endcode - //! - //! Also note that `maximum.by` is not tag-dispatched on its own, since it - //! is just syntactic sugar for calling the corresponding `maximum`. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto maximum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct maximum_impl : maximum_impl<T, when<true>> { }; - - template <typename T, typename = void> - struct maximum_pred_impl : maximum_pred_impl<T, when<true>> { }; - - struct maximum_t : detail::nested_by<maximum_t> { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const; - - template <typename Xs, typename Predicate> - constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; - }; - - constexpr maximum_t maximum{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MAXIMUM_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/members.hpp b/contrib/restricted/boost/boost/hana/fwd/members.hpp deleted file mode 100644 index a9f2d82bfb..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/members.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Forward declares `boost::hana::members`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MEMBERS_HPP -#define BOOST_HANA_FWD_MEMBERS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Sequence` containing the members of a `Struct`. - //! @ingroup group-Struct - //! - //! Given a `Struct` object, `members` returns a `Sequence` containing - //! all the members of the `Struct`, in the same order as their respective - //! accessor appears in the `accessors` sequence. - //! - //! - //! Example - //! ------- - //! @include example/members.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto members = [](auto&& object) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct members_impl : members_impl<S, when<true>> { }; - - struct members_t { - template <typename Object> - constexpr auto operator()(Object&& object) const; - }; - - constexpr members_t members{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MEMBERS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/min.hpp b/contrib/restricted/boost/boost/hana/fwd/min.hpp deleted file mode 100644 index 349787b571..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/min.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Forward declares `boost::hana::min`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MIN_HPP -#define BOOST_HANA_FWD_MIN_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the smallest of its arguments according to the `less` ordering. - //! @ingroup group-Orderable - //! - //! - //! @todo - //! We can't specify the signature right now, because the tag of the - //! returned object depends on whether `x < y` or not. If we wanted to be - //! mathematically correct, we should probably ask that `if_(cond, x, y)` - //! returns a common data type of `x` and `y`, and then the behavior - //! of `min` would follow naturally. However, I'm unsure whether this - //! is desirable because that's a big requirement. - //! - //! - //! Example - //! ------- - //! @include example/min.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto min = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct min_impl : min_impl<T, U, when<true>> { }; - - struct min_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr min_t min{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MIN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/minimum.hpp b/contrib/restricted/boost/boost/hana/fwd/minimum.hpp deleted file mode 100644 index df80196bc6..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/minimum.hpp +++ /dev/null @@ -1,116 +0,0 @@ -/*! -@file -Forward declares `boost::hana::minimum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MINIMUM_HPP -#define BOOST_HANA_FWD_MINIMUM_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the least element of a non-empty structure with respect to - //! a `predicate`, by default `less`. - //! @ingroup group-Foldable - //! - //! Given a non-empty structure and an optional binary predicate - //! (`less` by default), `minimum` returns the least element of - //! the structure, i.e. an element which is less than or equal to - //! every other element in the structure, according to the predicate. - //! - //! If the structure contains heterogeneous objects, then the predicate - //! must return a compile-time `Logical`. If no predicate is provided, - //! the elements in the structure must be Orderable, or compile-time - //! Orderable if the structure is heterogeneous. - //! - //! - //! Signature - //! --------- - //! Given a `Foldable` `F`, a Logical `Bool` and a predicate - //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `minimum` has the - //! following signatures. For the variant with a provided predicate, - //! \f[ - //! \mathtt{minimum} : F(T) \times (T \times T \to Bool) \to T - //! \f] - //! - //! for the variant without a custom predicate, `T` is required to be - //! Orderable. The signature is then - //! \f[ - //! \mathtt{minimum} : F(T) \to T - //! \f] - //! - //! @param xs - //! The structure to find the least element of. - //! - //! @param predicate - //! A function called as `predicate(x, y)`, where `x` and `y` are elements - //! of the structure. `predicate` should be a strict weak ordering on the - //! elements of the structure and its return value should be a Logical, - //! or a compile-time Logical if the structure is heterogeneous. - //! - //! ### Example - //! @include example/minimum.cpp - //! - //! - //! Syntactic sugar (`minimum.by`) - //! ------------------------------ - //! `minimum` can be called in a third way, which provides a nice syntax - //! especially when working with the `ordering` combinator: - //! @code - //! minimum.by(predicate, xs) == minimum(xs, predicate) - //! minimum.by(predicate) == minimum(-, predicate) - //! @endcode - //! - //! where `minimum(-, predicate)` denotes the partial application of - //! `minimum` to `predicate`. - //! - //! ### Example - //! @include example/minimum_by.cpp - //! - //! - //! Tag dispatching - //! --------------- - //! Both the non-predicated version and the predicated versions of - //! `minimum` are tag-dispatched methods, and hence they can be - //! customized independently. One reason for this is that some - //! structures are able to provide a much more efficient implementation - //! of `minimum` when the `less` predicate is used. Here is how the - //! different versions of `minimum` are dispatched: - //! @code - //! minimum(xs) -> minimum_impl<tag of xs>::apply(xs) - //! minimum(xs, pred) -> minimum_pred_impl<tag of xs>::apply(xs, pred) - //! @endcode - //! - //! Also note that `minimum.by` is not tag-dispatched on its own, since it - //! is just syntactic sugar for calling the corresponding `minimum`. -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto minimum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct minimum_impl : minimum_impl<T, when<true>> { }; - - template <typename T, typename = void> - struct minimum_pred_impl : minimum_pred_impl<T, when<true>> { }; - - struct minimum_t : detail::nested_by<minimum_t> { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const; - - template <typename Xs, typename Predicate> - constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; - }; - - constexpr minimum_t minimum{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MINIMUM_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/minus.hpp b/contrib/restricted/boost/boost/hana/fwd/minus.hpp deleted file mode 100644 index 3b3b3ff428..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/minus.hpp +++ /dev/null @@ -1,67 +0,0 @@ -/*! -@file -Forward declares `boost::hana::minus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MINUS_HPP -#define BOOST_HANA_FWD_MINUS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Subtract two elements of a group. - //! @ingroup group-Group - //! - //! Specifically, this performs the `Monoid` operation on the first - //! argument and on the inverse of the second argument, thus being - //! equivalent to: - //! @code - //! minus(x, y) == plus(x, negate(y)) - //! @endcode - //! - //! - //! Cross-type version of the method - //! -------------------------------- - //! The `minus` method is "overloaded" to handle distinct data types - //! with certain properties. Specifically, `minus` is defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `Group`s when taken individually - //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Group`-embeddings, as - //! determined by the `is_embedding` metafunction. - //! - //! The definition of `minus` for data types satisfying the above - //! properties is obtained by setting - //! @code - //! minus(x, y) = minus(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/minus.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto minus = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct minus_impl : minus_impl<T, U, when<true>> { }; - - struct minus_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr minus_t minus{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MINUS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/mod.hpp b/contrib/restricted/boost/boost/hana/fwd/mod.hpp deleted file mode 100644 index c0872803fc..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/mod.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Forward declares `boost::hana::mod`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MOD_HPP -#define BOOST_HANA_FWD_MOD_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Generalized integer modulus. - //! @ingroup group-EuclideanRing - //! - //! Given two elements of an EuclideanRing `x` and `y`, with `y` - //! nonzero, `mod` returns the modulus of the division of `x` by `y`. - //! In other words, `mod` can be seen as an equivalent to `%`. - //! - //! Cross-type version of the method - //! -------------------------------- - //! The `mod` method is "overloaded" to handle distinct data types - //! with certain properties. Specifically, `mod` is defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually - //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as - //! determined by the `is_embedding` metafunction. - //! - //! In that case, `mod` is defined as - //! @code - //! mod(x, y) = mod(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/mod.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto mod = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct mod_impl : mod_impl<T, U, when<true>> { }; - - struct mod_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr mod_t mod{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MOD_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/monadic_compose.hpp b/contrib/restricted/boost/boost/hana/fwd/monadic_compose.hpp deleted file mode 100644 index e9adde1bc2..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/monadic_compose.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Forward declares `boost::hana::monadic_compose`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MONADIC_COMPOSE_HPP -#define BOOST_HANA_FWD_MONADIC_COMPOSE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Composition of monadic functions. - //! @ingroup group-Monad - //! - //! Given two monadic functions `f` and `g`, `monadic_compose` returns - //! a new function equivalent to the composition of `f` with `g`, except - //! the result of `g` is `chain`ed into `f` instead of simply passed to - //! it, as with normal composition. `monadic_compose` satisfies - //! @code - //! monadic_compose(f, g)(x) == chain(g(x), f) - //! @endcode - //! - //! - //! @note - //! Unlike `compose`, `monadic_compose` does not generalize nicely to - //! arities higher than one. Hence, only unary functions may be used - //! with `monadic_compose`. - //! - //! - //! Signature - //! --------- - //! Given a `Monad` `M` and two functions @f$ f : B \to M(C) @f$ and - //! @f$ g : A \to M(B) @f$, the signature is - //! @f$ - //! \mathtt{monadic\_compose} - //! : (B \to M(C)) \times (A \to M(B)) \to (A \to M(C)) - //! @f$. - //! - //! @param f - //! A monadic function with signature @f$ B \to M(C) @f$. - //! - //! @param g - //! A monadic function with signature @f$ A \to M(B) @f$. - //! - //! - //! @note - //! This method is not tag-dispatched, so it can't be customized directly. - //! - //! - //! Example - //! ------- - //! @include example/monadic_compose.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto monadic_compose = [](auto&& f, auto&& g) { - return [perfect-capture](auto&& x) -> decltype(auto) { - return hana::chain(forwarded(g)(forwarded(x)), forwarded(f)); - }; - }; -#else - struct monadic_compose_t { - template <typename F, typename G> - constexpr auto operator()(F&& f, G&& g) const; - }; - - constexpr monadic_compose_t monadic_compose{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MONADIC_COMPOSE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/monadic_fold_left.hpp b/contrib/restricted/boost/boost/hana/fwd/monadic_fold_left.hpp deleted file mode 100644 index c037989dea..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/monadic_fold_left.hpp +++ /dev/null @@ -1,104 +0,0 @@ -/*! -@file -Forward declares `boost::hana::monadic_fold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP -#define BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Monadic left-fold of a structure with a binary operation and an - //! optional initial reduction state. - //! @ingroup group-Foldable - //! - //! @note - //! This assumes the reader to be accustomed to non-monadic left-folds as - //! explained by `hana::fold_left`, and to have read the [primer] - //! (@ref monadic-folds) on monadic folds. - //! - //! `monadic_fold_left<M>` is a left-associative monadic fold. Given a - //! `Foldable` with linearization `[x1, ..., xn]`, a function `f` and an - //! optional initial state, `monadic_fold_left<M>` applies `f` as follows: - //! @code - //! // with state - //! ((((f(state, x1) | f(-, x2)) | f(-, x3)) | ...) | f(-, xn)) - //! - //! // without state - //! ((((f(x1, x2) | f(-, x3)) | f(-, x4)) | ...) | f(-, xn)) - //! @endcode - //! - //! where `f(-, xk)` denotes the partial application of `f` to `xk`, and - //! `|` is just the operator version of the monadic `chain`. - //! - //! When the structure is empty, one of two things may happen. If an - //! initial state was provided, it is lifted to the given Monad and - //! returned as-is. Otherwise, if the no-state version of the function - //! was used, an error is triggered. When the stucture contains a single - //! element and the no-state version of the function was used, that - //! single element is lifted into the given Monad and returned as is. - //! - //! - //! Signature - //! --------- - //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, - //! and a function @f$ f : S \times T \to M(S) @f$, the signatures of - //! `monadic_fold_left<M>` are - //! \f[ - //! \mathtt{monadic\_fold\_left}_M : - //! F(T) \times S \times (S \times T \to M(S)) \to M(S) - //! \f] - //! - //! for the version with an initial state, and - //! \f[ - //! \mathtt{monadic\_fold\_left}_M : - //! F(T) \times (T \times T \to M(T)) \to M(T) - //! \f] - //! - //! for the version without an initial state. - //! - //! @tparam M - //! The Monad representing the monadic context in which the fold happens. - //! The return type of `f` must be in that Monad. - //! - //! @param xs - //! The structure to fold. - //! - //! @param state - //! The initial value used for folding. If the structure is empty, this - //! value is lifted in to the `M` Monad and then returned as-is. - //! - //! @param f - //! A binary function called as `f(state, x)`, where `state` is the result - //! accumulated so far and `x` is an element in the structure. The - //! function must return its result inside the `M` Monad. - //! - //! - //! Example - //! ------- - //! @include example/monadic_fold_left.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto monadic_fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct monadic_fold_left_impl : monadic_fold_left_impl<T, when<true>> { }; - - template <typename M> - struct monadic_fold_left_t; - - template <typename M> - constexpr monadic_fold_left_t<M> monadic_fold_left{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/monadic_fold_right.hpp b/contrib/restricted/boost/boost/hana/fwd/monadic_fold_right.hpp deleted file mode 100644 index 2028e15369..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/monadic_fold_right.hpp +++ /dev/null @@ -1,106 +0,0 @@ -/*! -@file -Forward declares `boost::hana::monadic_fold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP -#define BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Monadic right-fold of a structure with a binary operation and an - //! optional initial reduction state. - //! @ingroup group-Foldable - //! - //! @note - //! This assumes the reader to be accustomed to non-monadic right-folds as - //! explained by `hana::fold_right`, and to have read the [primer] - //! (@ref monadic-folds) on monadic folds. - //! - //! `monadic_fold_right<M>` is a right-associative monadic fold. Given a - //! structure containing `x1, ..., xn`, a function `f` and an optional - //! initial state, `monadic_fold_right<M>` applies `f` as follows - //! @code - //! // with state - //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn, state))))) - //! - //! // without state - //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn-1, xn))))) - //! @endcode - //! - //! where `f(xk, -)` denotes the partial application of `f` to `xk`, - //! and `|` is just the operator version of the monadic `chain`. - //! It is worth noting that the order in which the binary function should - //! expect its arguments is reversed from `monadic_fold_left<M>`. - //! - //! When the structure is empty, one of two things may happen. If an - //! initial state was provided, it is lifted to the given Monad and - //! returned as-is. Otherwise, if the no-state version of the function - //! was used, an error is triggered. When the stucture contains a single - //! element and the no-state version of the function was used, that - //! single element is lifted into the given Monad and returned as is. - //! - //! - //! Signature - //! --------- - //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, - //! and a function @f$ f : T \times S \to M(S) @f$, the signatures of - //! `monadic_fold_right<M>` are - //! \f[ - //! \mathtt{monadic\_fold\_right}_M : - //! F(T) \times S \times (T \times S \to M(S)) \to M(S) - //! \f] - //! - //! for the version with an initial state, and - //! \f[ - //! \mathtt{monadic\_fold\_right}_M : - //! F(T) \times (T \times T \to M(T)) \to M(T) - //! \f] - //! - //! for the version without an initial state. - //! - //! @tparam M - //! The Monad representing the monadic context in which the fold happens. - //! The return type of `f` must be in that Monad. - //! - //! @param xs - //! The structure to fold. - //! - //! @param state - //! The initial value used for folding. If the structure is empty, this - //! value is lifted in to the `M` Monad and then returned as-is. - //! - //! @param f - //! A binary function called as `f(x, state)`, where `state` is the result - //! accumulated so far and `x` is an element in the structure. The - //! function must return its result inside the `M` Monad. - //! - //! - //! Example - //! ------- - //! @include example/monadic_fold_right.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto monadic_fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct monadic_fold_right_impl : monadic_fold_right_impl<T, when<true>> { }; - - template <typename M> - struct monadic_fold_right_t; - - template <typename M> - constexpr monadic_fold_right_t<M> monadic_fold_right{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/mult.hpp b/contrib/restricted/boost/boost/hana/fwd/mult.hpp deleted file mode 100644 index d322071d9c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/mult.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::mult`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_MULT_HPP -#define BOOST_HANA_FWD_MULT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Associative operation of a `Ring`. - //! @ingroup group-Ring - //! - //! @param x, y - //! Two `Ring` elements to combine with the `Ring` binary operation. - //! - //! - //! Cross-type version of the method - //! -------------------------------- - //! The `mult` method is "overloaded" to handle distinct data types - //! with certain properties. Specifically, `mult` is defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `Ring`s when taken individually - //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as - //! determined by the `is_embedding` metafunction. - //! - //! The definition of `mult` for data types satisfying the above - //! properties is obtained by setting - //! @code - //! mult(x, y) = mult(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/mult.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto mult = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct mult_impl : mult_impl<T, U, when<true>> { }; - - struct mult_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr mult_t mult{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_MULT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/negate.hpp b/contrib/restricted/boost/boost/hana/fwd/negate.hpp deleted file mode 100644 index 6c4f70da8d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/negate.hpp +++ /dev/null @@ -1,42 +0,0 @@ -/*! -@file -Forward declares `boost::hana::negate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_NEGATE_HPP -#define BOOST_HANA_FWD_NEGATE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the inverse of an element of a group. - //! @ingroup group-Group - //! - //! - //! Example - //! ------- - //! @include example/negate.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto negate = [](auto&& x) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename G, typename = void> - struct negate_impl : negate_impl<G, when<true>> { }; - - struct negate_t { - template <typename X> - constexpr decltype(auto) operator()(X&& x) const; - }; - - constexpr negate_t negate{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_NEGATE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/none.hpp b/contrib/restricted/boost/boost/hana/fwd/none.hpp deleted file mode 100644 index d0d2da94a9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/none.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Forward declares `boost::hana::none`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_NONE_HPP -#define BOOST_HANA_FWD_NONE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether all of the keys of the structure are false-valued. - //! @ingroup group-Searchable - //! - //! The keys of the structure must be `Logical`s. If the structure is not - //! finite, a true-valued key must appear at a finite "index" in order - //! for this method to finish. - //! - //! - //! Example - //! ------- - //! @include example/none.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto none = [](auto&& xs) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct none_impl : none_impl<S, when<true>> { }; - - struct none_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr none_t none{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_NONE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/none_of.hpp b/contrib/restricted/boost/boost/hana/fwd/none_of.hpp deleted file mode 100644 index 3e57cf1d65..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/none_of.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Forward declares `boost::hana::none_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_NONE_OF_HPP -#define BOOST_HANA_FWD_NONE_OF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns whether none of the keys of the structure satisfy the - //! `predicate`. - //! @ingroup group-Searchable - //! - //! If the structure is not finite, `predicate` has to return a true- - //! valued `Logical` after looking at a finite number of keys for this - //! method to finish. - //! - //! - //! @param xs - //! The structure to search. - //! - //! @param predicate - //! A function called as `predicate(k)`, where `k` is a key of the - //! structure, and returning a `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/none_of.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto none_of = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct none_of_impl : none_of_impl<S, when<true>> { }; - - struct none_of_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr none_of_t none_of{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_NONE_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/not.hpp b/contrib/restricted/boost/boost/hana/fwd/not.hpp deleted file mode 100644 index 08d19d2bd5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/not.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*! -@file -Forward declares `boost::hana::not_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_NOT_HPP -#define BOOST_HANA_FWD_NOT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Negates a `Logical`. - //! @ingroup group-Logical - //! - //! This method returns a `Logical` with the same tag, but whose - //! truth-value is negated. Specifically, `not_(x)` returns a false-valued - //! `Logical` if `x` is a true-valued `Logical`, and a true-valued one - //! otherwise. - //! - //! - //! Example - //! ------- - //! @include example/not.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto not_ = [](auto&& x) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct not_impl : not_impl<L, when<true>> { }; - - struct not_t { - template <typename X> - constexpr decltype(auto) operator()(X&& x) const; - }; - - constexpr not_t not_{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_NOT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/not_equal.hpp b/contrib/restricted/boost/boost/hana/fwd/not_equal.hpp deleted file mode 100644 index 7063a3796c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/not_equal.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Forward declares `boost::hana::not_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_NOT_EQUAL_HPP -#define BOOST_HANA_FWD_NOT_EQUAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_to_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Logical` representing whether `x` is not equal to `y`. - //! @ingroup group-Comparable - //! - //! The `not_equal` function can be called in two different ways. First, - //! it can be called like a normal function: - //! @code - //! not_equal(x, y) - //! @endcode - //! - //! However, it may also be partially applied to an argument by using - //! `not_equal.to`: - //! @code - //! not_equal.to(x)(y) == not_equal(x, y) - //! @endcode - //! - //! In other words, `not_equal.to(x)` is a function object that is - //! equivalent to `partial(not_equal, x)`. This is provided to enhance - //! the readability of some constructs, especially when using higher - //! order algorithms. - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and two Comparables `A` and `B` that - //! share a common embedding, the signature is - //! @f$ \mathtt{not\_equal} : A \times B \to Bool @f$. - //! - //! @param x, y - //! Two objects to compare for inequality. - //! - //! - //! Example - //! ------- - //! @include example/not_equal.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto not_equal = [](auto&& x, auto&& y) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct not_equal_impl : not_equal_impl<T, U, when<true>> { }; - - struct not_equal_t : detail::nested_to<not_equal_t> { - template <typename X, typename Y> - constexpr auto operator()(X&& x, Y&& y) const; - }; - - constexpr not_equal_t not_equal{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_NOT_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/one.hpp b/contrib/restricted/boost/boost/hana/fwd/one.hpp deleted file mode 100644 index d2c67b7228..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/one.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Forward declares `boost::hana::one`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ONE_HPP -#define BOOST_HANA_FWD_ONE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Identity of the `Ring` multiplication. - //! @ingroup group-Ring - //! - //! @tparam R - //! The tag (must be a model of `Ring`) of the returned identity. - //! - //! - //! Example - //! ------- - //! @include example/one.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename R> - constexpr auto one = []() -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename R, typename = void> - struct one_impl : one_impl<R, when<true>> { }; - - template <typename R> - struct one_t; - - template <typename R> - constexpr one_t<R> one{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ONE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/optional.hpp b/contrib/restricted/boost/boost/hana/fwd/optional.hpp deleted file mode 100644 index 28bb68e8af..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/optional.hpp +++ /dev/null @@ -1,510 +0,0 @@ -/*! -@file -Forward declares `boost::hana::optional`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_OPTIONAL_HPP -#define BOOST_HANA_FWD_OPTIONAL_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/fwd/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! Optional value whose optional-ness is known at compile-time. - //! - //! An `optional` either contains a value (represented as `just(x)`), or - //! it is empty (represented as `nothing`). In essence, `hana::optional` - //! is pretty much like a `boost::optional` or the upcoming `std::optional`, - //! except for the fact that whether a `hana::optional` is empty or not is - //! known at compile-time. This can be particularly useful for returning - //! from a function that might fail, but whose reason for failing is not - //! important. Of course, whether the function will fail has to be known - //! at compile-time. - //! - //! This is really an important difference between `hana::optional` and - //! `std::optional`. Unlike `std::optional<T>{}` and `std::optional<T>{x}` - //! who share the same type (`std::optional<T>`), `hana::just(x)` and - //! `hana::nothing` do not share the same type, since the state of the - //! optional has to be known at compile-time. Hence, whether a `hana::just` - //! or a `hana::nothing` will be returned from a function has to be known - //! at compile-time for the return type of that function to be computable - //! by the compiler. This makes `hana::optional` well suited for static - //! metaprogramming tasks, but very poor for anything dynamic. - //! - //! - //! Interoperation with `type`s - //! --------------------------- - //! When a `just` contains an object of type `T` which is a `type`, - //! it has a nested `::%type` alias equivalent to `T::%type`. `nothing`, - //! however, never has a nested `::%type` alias. If `t` is a `type`, - //! this allows `decltype(just(t))` to be seen as a nullary metafunction - //! equivalent to `decltype(t)`. Along with the `sfinae` function, - //! this allows `hana::optional` to interact seamlessly with - //! SFINAE-friendly metafunctions. - //! Example: - //! @include example/optional/sfinae_friendly_metafunctions.cpp - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two `optional`s are equal if and only if they are both empty or they - //! both contain a value and those values are equal. - //! @include example/optional/comparable.cpp - //! - //! 2. `Orderable`\n - //! Optional values can be ordered by considering the value they are - //! holding, if any. To handle the case of an empty optional value, we - //! arbitrarily set `nothing` as being less than any other `just`. Hence, - //! @code - //! just(x) < just(y) if and only if x < y - //! nothing < just(anything) - //! @endcode - //! Example: - //! @include example/optional/orderable.cpp - //! - //! 3. `Functor`\n - //! An optional value can be seen as a list containing either one element - //! (`just(x)`) or no elements at all (`nothing`). As such, mapping - //! a function over an optional value is equivalent to applying it to - //! its value if there is one, and to `nothing` otherwise: - //! @code - //! transform(just(x), f) == just(f(x)) - //! transform(nothing, f) == nothing - //! @endcode - //! Example: - //! @include example/optional/functor.cpp - //! - //! 4. `Applicative`\n - //! First, a value can be made optional with `lift<optional_tag>`, which - //! is equivalent to `just`. Second, one can feed an optional value to an - //! optional function with `ap`, which will return `just(f(x))` if there - //! is both a function _and_ a value, and `nothing` otherwise: - //! @code - //! ap(just(f), just(x)) == just(f(x)) - //! ap(nothing, just(x)) == nothing - //! ap(just(f), nothing) == nothing - //! ap(nothing, nothing) == nothing - //! @endcode - //! A simple example: - //! @include example/optional/applicative.cpp - //! A more complex example: - //! @include example/optional/applicative.complex.cpp - //! - //! 5. `Monad`\n - //! The `Monad` model makes it easy to compose actions that might fail. - //! One can feed an optional value if there is one into a function with - //! `chain`, which will return `nothing` if there is no value. Finally, - //! optional-optional values can have their redundant level of optionality - //! removed with `flatten`. Also note that the `|` operator can be used in - //! place of the `chain` function. - //! Example: - //! @include example/optional/monad.cpp - //! - //! 6. `MonadPlus`\n - //! The `MonadPlus` model allows choosing the first valid value out of - //! two optional values with `concat`. If both optional values are - //! `nothing`s, `concat` will return `nothing`. - //! Example: - //! @include example/optional/monad_plus.cpp - //! - //! 7. `Foldable`\n - //! Folding an optional value is equivalent to folding a list containing - //! either no elements (for `nothing`) or `x` (for `just(x)`). - //! Example: - //! @include example/optional/foldable.cpp - //! - //! 8. `Searchable`\n - //! Searching an optional value is equivalent to searching a list - //! containing `x` for `just(x)` and an empty list for `nothing`. - //! Example: - //! @include example/optional/searchable.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename ...T> - struct optional { - // 5.3.1, Constructors - - //! Default-construct an `optional`. Only exists if the optional - //! contains a value, and if that value is DefaultConstructible. - constexpr optional() = default; - - //! Copy-construct an `optional`. - //! An empty optional may only be copy-constructed from another - //! empty `optional`, and an `optional` with a value may only be - //! copy-constructed from another `optional` with a value. - //! Furthermore, this constructor only exists if the value - //! held in the `optional` is CopyConstructible. - optional(optional const&) = default; - - //! Move-construct an `optional`. - //! An empty optional may only be move-constructed from another - //! empty `optional`, and an `optional` with a value may only be - //! move-constructed from another `optional` with a value. - //! Furthermore, this constructor only exists if the value - //! held in the `optional` is MoveConstructible. - optional(optional&&) = default; - - //! Construct an `optional` holding a value of type `T` from another - //! object of type `T`. The value is copy-constructed. - constexpr optional(T const& t) - : value_(t) - { } - - //! Construct an `optional` holding a value of type `T` from another - //! object of type `T`. The value is move-constructed. - constexpr optional(T&& t) - : value_(static_cast<T&&>(t)) - { } - - // 5.3.3, Assignment - - //! Copy-assign an `optional`. - //! An empty optional may only be copy-assigned from another empty - //! `optional`, and an `optional` with a value may only be copy-assigned - //! from another `optional` with a value. Furthermore, this assignment - //! operator only exists if the value held in the `optional` is - //! CopyAssignable. - constexpr optional& operator=(optional const&) = default; - - //! Move-assign an `optional`. - //! An empty optional may only be move-assigned from another empty - //! `optional`, and an `optional` with a value may only be move-assigned - //! from another `optional` with a value. Furthermore, this assignment - //! operator only exists if the value held in the `optional` is - //! MoveAssignable. - constexpr optional& operator=(optional&&) = default; - - // 5.3.5, Observers - - //! Returns a pointer to the contained value, or a `nullptr` if the - //! `optional` is empty. - //! - //! - //! @note Overloads of this method are provided for both the `const` - //! and the non-`const` cases. - //! - //! - //! Example - //! ------- - //! @include example/optional/value.cpp - constexpr T* operator->(); - - //! Extract the content of an `optional`, or fail at compile-time. - //! - //! If `*this` contains a value, that value is returned. Otherwise, - //! a static assertion is triggered. - //! - //! @note - //! Overloads of this method are provided for the cases where `*this` - //! is a reference, a rvalue-reference and their `const` counterparts. - //! - //! - //! Example - //! ------- - //! @include example/optional/value.cpp - constexpr T& value(); - - //! Equivalent to `value()`, provided for convenience. - //! - //! @note - //! Overloads of this method are provided for the cases where `*this` - //! is a reference, a rvalue-reference and their `const` counterparts. - //! - //! - //! Example - //! ------- - //! @include example/optional/value.cpp - constexpr T& operator*(); - - //! Return the contents of an `optional`, with a fallback result. - //! - //! If `*this` contains a value, that value is returned. Otherwise, - //! the default value provided is returned. - //! - //! @note - //! Overloads of this method are provided for the cases where `*this` - //! is a reference, a rvalue-reference and their `const` counterparts. - //! - //! - //! @param default_ - //! The default value to return if `*this` does not contain a value. - //! - //! - //! Example - //! ------- - //! @include example/optional/value_or.cpp - template <typename U> - constexpr decltype(auto) value_or(U&& default_); - - //! Equivalent to `hana::chain`. - template <typename ...T, typename F> - friend constexpr auto operator|(optional<T...>, F); - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::less` - template <typename X, typename Y> - friend constexpr auto operator<(X&& x, Y&& y); - - //! Equivalent to `hana::greater` - template <typename X, typename Y> - friend constexpr auto operator>(X&& x, Y&& y); - - //! Equivalent to `hana::less_equal` - template <typename X, typename Y> - friend constexpr auto operator<=(X&& x, Y&& y); - - //! Equivalent to `hana::greater_equal` - template <typename X, typename Y> - friend constexpr auto operator>=(X&& x, Y&& y); - }; -#else - template <typename ...T> - struct optional; -#endif - - //! Tag representing a `hana::optional`. - //! @relates hana::optional - struct optional_tag { }; - - //! Create an optional value. - //! @relates hana::optional - //! - //! Specifically, `make<optional_tag>()` is equivalent to `nothing`, and - //! `make<optional_tag>(x)` is equivalent to `just(x)`. This is provided - //! for consistency with the other `make<...>` functions. - //! - //! - //! Example - //! ------- - //! @include example/optional/make.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <> - constexpr auto make<optional_tag> = []([auto&& x]) { - return optional<std::decay<decltype(x)>::type>{forwarded(x)}; - }; -#endif - - //! Alias to `make<optional_tag>`; provided for convenience. - //! @relates hana::optional - //! - //! - //! Example - //! ------- - //! @include example/optional/make.cpp - constexpr auto make_optional = make<optional_tag>; - - //! Create an optional value containing `x`. - //! @relates hana::optional - //! - //! - //! Example - //! ------- - //! @include example/optional/just.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto just = [](auto&& x) { - return optional<std::decay<decltype(x)>::type>{forwarded(x)}; - }; -#else - struct make_just_t { - template <typename T> - constexpr auto operator()(T&&) const; - }; - - constexpr make_just_t just{}; -#endif - - //! An empty optional value. - //! @relates hana::optional - //! - //! - //! Example - //! ------- - //! @include example/optional/nothing.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr optional<> nothing{}; -#else - template <> - struct optional<> : detail::operators::adl<optional<>> { - // 5.3.1, Constructors - constexpr optional() = default; - constexpr optional(optional const&) = default; - constexpr optional(optional&&) = default; - - // 5.3.3, Assignment - constexpr optional& operator=(optional const&) = default; - constexpr optional& operator=(optional&&) = default; - - // 5.3.5, Observers - constexpr decltype(nullptr) operator->() const { return nullptr; } - - template <typename ...dummy> - constexpr auto value() const; - - template <typename ...dummy> - constexpr auto operator*() const; - - template <typename U> - constexpr U&& value_or(U&& u) const; - }; - - constexpr optional<> nothing{}; -#endif - - //! Apply a function to the contents of an optional, with a fallback - //! result. - //! @relates hana::optional - //! - //! Specifically, `maybe` takes a default value, a function and an - //! optional value. If the optional value is `nothing`, the default - //! value is returned. Otherwise, the function is applied to the - //! content of the `just`. - //! - //! - //! @param default_ - //! A default value returned if `m` is `nothing`. - //! - //! @param f - //! A function called as `f(x)` if and only if `m` is an optional value - //! of the form `just(x)`. In that case, the result returend by `maybe` - //! is the result of `f`. - //! - //! @param m - //! An optional value. - //! - //! - //! Example - //! ------- - //! @include example/optional/maybe.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto maybe = [](auto&& default_, auto&& f, auto&& m) -> decltype(auto) { - if (m is a just(x)) { - return forwarded(f)(forwarded(x)); - else - return forwarded(default_); - } - }; -#else - struct maybe_t { - template <typename Def, typename F, typename T> - constexpr decltype(auto) operator()(Def&&, F&& f, optional<T> const& m) const - { return static_cast<F&&>(f)(m.value_); } - - template <typename Def, typename F, typename T> - constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>& m) const - { return static_cast<F&&>(f)(m.value_); } - - template <typename Def, typename F, typename T> - constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>&& m) const - { return static_cast<F&&>(f)(static_cast<optional<T>&&>(m).value_); } - - template <typename Def, typename F> - constexpr Def operator()(Def&& def, F&&, optional<> const&) const - { return static_cast<Def&&>(def); } - }; - - constexpr maybe_t maybe{}; -#endif - - //! Calls a function if the call expression is well-formed. - //! @relates hana::optional - //! - //! Given a function `f`, `sfinae` returns a new function applying `f` - //! to its arguments and returning `just` the result if the call is - //! well-formed, and `nothing` otherwise. In other words, `sfinae(f)(x...)` - //! is `just(f(x...))` if that expression is well-formed, and `nothing` - //! otherwise. Note, however, that it is possible for an expression - //! `f(x...)` to be well-formed as far as SFINAE is concerned, but - //! trying to actually compile `f(x...)` still fails. In this case, - //! `sfinae` won't be able to detect it and a hard failure is likely - //! to happen. - //! - //! - //! @note - //! The function given to `sfinae` must not return `void`, since - //! `just(void)` does not make sense. A compilation error is - //! triggered if the function returns void. - //! - //! - //! Example - //! ------- - //! @include example/optional/sfinae.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto sfinae = [](auto&& f) { - return [perfect-capture](auto&& ...x) { - if (decltype(forwarded(f)(forwarded(x)...)) is well-formed) - return just(forwarded(f)(forwarded(x)...)); - else - return nothing; - }; - }; -#else - struct sfinae_t { - template <typename F> - constexpr decltype(auto) operator()(F&& f) const; - }; - - constexpr sfinae_t sfinae{}; -#endif - - //! Return whether an `optional` contains a value. - //! @relates hana::optional - //! - //! Specifically, returns a compile-time true-valued `Logical` if `m` is - //! of the form `just(x)` for some `x`, and a false-valued one otherwise. - //! - //! - //! Example - //! ------- - //! @include example/optional/is_just.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_just = [](auto const& m) { - return m is a just(x); - }; -#else - struct is_just_t { - template <typename ...T> - constexpr auto operator()(optional<T...> const&) const; - }; - - constexpr is_just_t is_just{}; -#endif - - //! Return whether an `optional` is empty. - //! @relates hana::optional - //! - //! Specifically, returns a compile-time true-valued `Logical` if `m` is - //! a `nothing`, and a false-valued one otherwise. - //! - //! - //! Example - //! ------- - //! @include example/optional/is_nothing.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_nothing = [](auto const& m) { - return m is a nothing; - }; -#else - struct is_nothing_t { - template <typename ...T> - constexpr auto operator()(optional<T...> const&) const; - }; - - constexpr is_nothing_t is_nothing{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_OPTIONAL_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/or.hpp b/contrib/restricted/boost/boost/hana/fwd/or.hpp deleted file mode 100644 index c14efc8e34..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/or.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Forward declares `boost::hana::or_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_OR_HPP -#define BOOST_HANA_FWD_OR_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return whether any of the arguments is true-valued. - //! @ingroup group-Logical - //! - //! `or_` can be called with one argument or more. When called with - //! two arguments, `or_` uses tag-dispatching to find the right - //! implementation. Otherwise, - //! @code - //! or_(x) == x - //! or_(x, y, ...z) == or_(or_(x, y), z...) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/or.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto or_ = [](auto&& x, auto&& ...y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct or_impl : or_impl<L, when<true>> { }; - - struct or_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - - template <typename X, typename ...Y> - constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; - }; - - constexpr or_t or_{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_OR_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/ordering.hpp b/contrib/restricted/boost/boost/hana/fwd/ordering.hpp deleted file mode 100644 index 78c9e2c3b8..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/ordering.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Forward declares `boost::hana::ordering`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ORDERING_HPP -#define BOOST_HANA_FWD_ORDERING_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a function performing `less` after applying a transformation - //! to both arguments. - //! @ingroup group-Orderable - //! - //! `ordering` creates a total order based on the result of applying a - //! function to some objects, which is especially useful in conjunction - //! with algorithms that accept a custom predicate that must represent - //! a total order. - //! - //! Specifically, `ordering` is such that - //! @code - //! ordering(f) == less ^on^ f - //! @endcode - //! or, equivalently, - //! @code - //! ordering(f)(x, y) == less(f(x), f(y)) - //! @endcode - //! - //! @note - //! This is not a tag-dispatched method (hence it can't be customized), - //! but just a convenience function provided with the `Orderable` concept. - //! - //! - //! Signature - //! --------- - //! Given a Logical `Bool` and an Orderable `B`, the signature is - //! @f$ \mathrm{ordering} : (A \to B) \to (A \times A \to Bool) @f$. - //! - //! - //! Example - //! ------- - //! @include example/ordering.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto ordering = [](auto&& f) { - return [perfect-capture](auto&& x, auto&& y) -> decltype(auto) { - return less(f(forwarded(x)), f(forwarded(y))); - }; - }; -#else - struct ordering_t { - template <typename F> - constexpr auto operator()(F&& f) const; - }; - - constexpr ordering_t ordering{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ORDERING_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/pair.hpp b/contrib/restricted/boost/boost/hana/fwd/pair.hpp deleted file mode 100644 index 897e87ad12..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/pair.hpp +++ /dev/null @@ -1,153 +0,0 @@ -/*! -@file -Forward declares `boost::hana::pair`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PAIR_HPP -#define BOOST_HANA_FWD_PAIR_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! Generic container for two elements. - //! - //! `hana::pair` is conceptually the same as `std::pair`. However, - //! `hana::pair` automatically compresses the storage of empty types, - //! and as a result it does not have the `.first` and `.second` members. - //! Instead, one must use the `hana::first` and `hana::second` free - //! functions to access the elements of a pair. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two pairs `(x, y)` and `(x', y')` are equal if and only if both - //! `x == x'` and `y == y'`. - //! @include example/pair/comparable.cpp - //! - //! 2. `Orderable`\n - //! Pairs are ordered as-if they were 2-element tuples, using a - //! lexicographical ordering. - //! @include example/pair/orderable.cpp - //! - //! 3. `Foldable`\n - //! Folding a pair is equivalent to folding a 2-element tuple. In other - //! words: - //! @code - //! fold_left(make_pair(x, y), s, f) == f(f(s, x), y) - //! fold_right(make_pair(x, y), s, f) == f(x, f(y, s)) - //! @endcode - //! Example: - //! @include example/pair/foldable.cpp - //! - //! 4. `Product`\n - //! The model of `Product` is the simplest one possible; the first element - //! of a pair `(x, y)` is `x`, and its second element is `y`. - //! @include example/pair/product.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename First, typename Second> - struct pair { - //! Default constructs the `pair`. Only exists when both elements - //! of the pair are default constructible. - constexpr pair(); - - //! Initialize each element of the pair with the corresponding element. - //! Only exists when both elements of the pair are copy-constructible. - constexpr pair(First const& first, Second const& second); - - //! Initialize both elements of the pair by perfect-forwarding the - //! corresponding argument. Only exists when both arguments are - //! implicitly-convertible to the corresponding element of the pair. - template <typename T, typename U> - constexpr pair(T&& t, U&& u); - - //! Copy-initialize a pair from another pair. Only exists when both - //! elements of the source pair are implicitly convertible to the - //! corresponding element of the constructed pair. - template <typename T, typename U> - constexpr pair(pair<T, U> const& other); - - //! Move-initialize a pair from another pair. Only exists when both - //! elements of the source pair are implicitly convertible to the - //! corresponding element of the constructed pair. - template <typename T, typename U> - constexpr pair(pair<T, U>&& other); - - //! Assign a pair to another pair. Only exists when both elements - //! of the destination pair are assignable from the corresponding - //! element in the source pair. - template <typename T, typename U> - constexpr pair& operator=(pair<T, U> const& other); - - //! Move-assign a pair to another pair. Only exists when both elements - //! of the destination pair are move-assignable from the corresponding - //! element in the source pair. - template <typename T, typename U> - constexpr pair& operator=(pair<T, U>&& other); - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::less` - template <typename X, typename Y> - friend constexpr auto operator<(X&& x, Y&& y); - - //! Equivalent to `hana::greater` - template <typename X, typename Y> - friend constexpr auto operator>(X&& x, Y&& y); - - //! Equivalent to `hana::less_equal` - template <typename X, typename Y> - friend constexpr auto operator<=(X&& x, Y&& y); - - //! Equivalent to `hana::greater_equal` - template <typename X, typename Y> - friend constexpr auto operator>=(X&& x, Y&& y); - }; -#else - template <typename First, typename Second> - struct pair; -#endif - - //! Tag representing `hana::pair`. - //! @relates hana::pair - struct pair_tag { }; - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Creates a `hana::pair` with the given elements. - //! @relates hana::pair - //! - //! - //! Example - //! ------- - //! @include example/pair/make.cpp - template <> - constexpr auto make<pair_tag> = [](auto&& first, auto&& second) - -> hana::pair<std::decay_t<decltype(first)>, std::decay_t<decltype(second)>> - { - return {forwarded(first), forwarded(second)}; - }; -#endif - - //! Alias to `make<pair_tag>`; provided for convenience. - //! @relates hana::pair - //! - //! Example - //! ------- - //! @include example/pair/make.cpp - constexpr auto make_pair = make<pair_tag>; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PAIR_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/partition.hpp b/contrib/restricted/boost/boost/hana/fwd/partition.hpp deleted file mode 100644 index b7a7d3a2ae..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/partition.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*! -@file -Forward declares `boost::hana::partition`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PARTITION_HPP -#define BOOST_HANA_FWD_PARTITION_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - - -BOOST_HANA_NAMESPACE_BEGIN - //! Partition a sequence based on a `predicate`. - //! @ingroup group-Sequence - //! - //! Specifically, returns an unspecified `Product` whose first element is - //! a sequence of the elements satisfying the predicate, and whose second - //! element is a sequence of the elements that do not satisfy the predicate. - //! - //! - //! Signature - //! --------- - //! Given a Sequence `S(T)`, an `IntegralConstant` `Bool` holding a value - //! of type `bool`, and a predicate \f$ T \to Bool \f$, `partition` has - //! the following signature: - //! \f[ - //! \mathtt{partition} : S(T) \times (T \to Bool) \to S(T) \times S(T) - //! \f] - //! - //! @param xs - //! The sequence to be partitioned. - //! - //! @param predicate - //! A function called as `predicate(x)` for each element `x` in the - //! sequence, and returning whether `x` should be added to the sequence - //! in the first component or in the second component of the resulting - //! pair. In the current version of the library, `predicate` must return - //! an `IntegralConstant` holding a value convertible to `bool`. - //! - //! - //! Syntactic sugar (`partition.by`) - //! -------------------------------- - //! `partition` can be called in an alternate way, which provides a nice - //! syntax in some cases where the predicate is short: - //! @code - //! partition.by(predicate, xs) == partition(xs, predicate) - //! partition.by(predicate) == partition(-, predicate) - //! @endcode - //! - //! where `partition(-, predicate)` denotes the partial application of - //! `partition` to `predicate`. - //! - //! - //! Example - //! ------- - //! @include example/partition.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto partition = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct partition_impl : partition_impl<S, when<true>> { }; - - struct partition_t : detail::nested_by<partition_t> { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr partition_t partition{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PARTITION_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/permutations.hpp b/contrib/restricted/boost/boost/hana/fwd/permutations.hpp deleted file mode 100644 index 7aeb27b2e8..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/permutations.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Forward declares `boost::hana::permutations`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PERMUTATIONS_HPP -#define BOOST_HANA_FWD_PERMUTATIONS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return a sequence of all the permutations of the given sequence. - //! @ingroup group-Sequence - //! - //! Specifically, `permutations(xs)` is a sequence whose elements are - //! permutations of the original sequence `xs`. The permutations are not - //! guaranteed to be in any specific order. Also note that the number - //! of permutations grows very rapidly as the length of the original - //! sequence increases. The growth rate is `O(length(xs)!)`; with a - //! sequence `xs` of length only 8, `permutations(xs)` contains over - //! 40 000 elements! - //! - //! - //! Example - //! ------- - //! @include example/permutations.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto permutations = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct permutations_impl : permutations_impl<S, when<true>> { }; - - struct permutations_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr permutations_t permutations{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PERMUTATIONS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/plus.hpp b/contrib/restricted/boost/boost/hana/fwd/plus.hpp deleted file mode 100644 index 6d6cac82e2..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/plus.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::plus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PLUS_HPP -#define BOOST_HANA_FWD_PLUS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Associative binary operation on a `Monoid`. - //! @ingroup group-Monoid - //! - //! @param x, y - //! Two objects to combine with the `Monoid`'s binary operation. - //! - //! - //! Cross-type version of the method - //! -------------------------------- - //! The `plus` method is "overloaded" to handle distinct data types - //! with certain properties. Specifically, `plus` is defined for - //! _distinct_ data types `A` and `B` such that - //! 1. `A` and `B` share a common data type `C`, as determined by the - //! `common` metafunction - //! 2. `A`, `B` and `C` are all `Monoid`s when taken individually - //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Monoid`-embeddings, as - //! determined by the `is_embedding` metafunction. - //! - //! The definition of `plus` for data types satisfying the above - //! properties is obtained by setting - //! @code - //! plus(x, y) = plus(to<C>(x), to<C>(y)) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/plus.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto plus = [](auto&& x, auto&& y) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename U, typename = void> - struct plus_impl : plus_impl<T, U, when<true>> { }; - - struct plus_t { - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const; - }; - - constexpr plus_t plus{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PLUS_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/power.hpp b/contrib/restricted/boost/boost/hana/fwd/power.hpp deleted file mode 100644 index c94b841194..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/power.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Forward declares `boost::hana::power`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_POWER_HPP -#define BOOST_HANA_FWD_POWER_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Elevate a ring element to its `n`th power. - //! @ingroup group-Ring - //! - //! Specifically, `power(x, n)`, is equivalent to multiplying `x` with - //! itself `n` times using the Ring's multiplication. If the power is - //! equal to `zero`, the Ring's identity (`one`) is returned. - //! - //! @param x - //! A `Ring` element that is elevated to its `n`th power. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the power to which `x` - //! is elevated. - //! - //! - //! @note - //! Only the tag of `x` is used for tag-dispatching. - //! - //! Example - //! ------- - //! @include example/power.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto power = [](auto&& x, auto const& n) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename R, typename = void> - struct power_impl : power_impl<R, when<true>> { }; - - struct power_t { - template <typename X, typename N> - constexpr decltype(auto) operator()(X&& x, N const& n) const; - }; - - constexpr power_t power{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_POWER_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/prefix.hpp b/contrib/restricted/boost/boost/hana/fwd/prefix.hpp deleted file mode 100644 index 78592e11f2..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/prefix.hpp +++ /dev/null @@ -1,72 +0,0 @@ -/*! -@file -Forward declares `boost::hana::prefix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PREFIX_HPP -#define BOOST_HANA_FWD_PREFIX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Inserts a value before each element of a monadic structure. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and a value `z` called the prefix, - //! `prefix` returns a new monadic structure. `prefix` satisfies - //! @code - //! prefix(xs, z) == flatten(transform(xs, [](auto x) { - //! return concat(lift<M>(z), lift<M>(x)); - //! })) - //! @endcode - //! - //! For sequences, this simply corresponds to inserting the prefix before - //! each element of the sequence. For example, given a sequence - //! `[x1, ..., xn]`, `prefix` will return - //! @code - //! [z, x1, z, x2, ..., z, xn] - //! @endcode - //! As explained above, this can be generalized to other MonadPlus models, - //! with various levels of interest. - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M`, the signature is - //! @f$ \mathrm{prefix} : M(T) \times T \to M(T) @f$. - //! - //! @param xs - //! A monadic structure. - //! - //! @param pref - //! A value (the prefix) to insert before each element of a monadic - //! structure. - //! - //! - //! Example - //! ------- - //! @include example/prefix.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto prefix = [](auto&& xs, auto&& pref) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct prefix_impl : prefix_impl<M, when<true>> { }; - - struct prefix_t { - template <typename Xs, typename Pref> - constexpr auto operator()(Xs&& xs, Pref&& pref) const; - }; - - constexpr prefix_t prefix{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PREFIX_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/prepend.hpp b/contrib/restricted/boost/boost/hana/fwd/prepend.hpp deleted file mode 100644 index 8bb44ea2db..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/prepend.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/*! -@file -Forward declares `boost::hana::prepend`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PREPEND_HPP -#define BOOST_HANA_FWD_PREPEND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Prepend an element to a monadic structure. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and an element `x`, `prepend` returns - //! a new monadic structure which is the result of lifting `x` into the - //! monadic structure and then combining that (to the left) with `xs`. - //! In other words, - //! @code - //! prepend(xs, x) == concat(lift<Xs>(x), xs) - //! @endcode - //! - //! For sequences, this has the intuitive behavior of simply prepending - //! an element to the beginning of the sequence, hence the name. - //! - //! > #### Rationale for not calling this `push_front` - //! > While `push_front` is the de-facto name used in the standard library, - //! > it also strongly suggests mutation of the underlying sequence, which - //! > is not the case here. The author also finds that `push_front` - //! > suggests too strongly the sole interpretation of putting an - //! > element to the front of a sequence, whereas `prepend` is slightly - //! > more nuanced and bears its name better for e.g. `hana::optional`. - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M`, the signature is - //! @f$ \mathtt{prepend} : M(T) \times T \to M(T) @f$. - //! - //! @param xs - //! A monadic structure that will be combined to the right of the element. - //! - //! @param x - //! An element to combine to the left of the monadic structure. - //! - //! - //! Example - //! ------- - //! @include example/prepend.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto prepend = [](auto&& xs, auto&& x) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct prepend_impl : prepend_impl<M, when<true>> { }; - - struct prepend_t { - template <typename Xs, typename X> - constexpr auto operator()(Xs&& xs, X&& x) const; - }; - - constexpr prepend_t prepend{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PREPEND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/product.hpp b/contrib/restricted/boost/boost/hana/fwd/product.hpp deleted file mode 100644 index 96bbd77c4e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/product.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Forward declares `boost::hana::product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_PRODUCT_HPP -#define BOOST_HANA_FWD_PRODUCT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Compute the product of the numbers of a structure. - //! @ingroup group-Foldable - //! - //! More generally, `product` will take any foldable structure containing - //! objects forming a Ring and reduce them using the Ring's binary - //! operation. The initial state for folding is the identity of the - //! Ring's operation. It is sometimes necessary to specify the Ring to - //! use; this is possible by using `product<R>`. If no Ring is specified, - //! the structure will use the Ring formed by the elements it contains - //! (if it knows it), or `integral_constant_tag<int>` otherwise. - //! Hence, - //! @code - //! product<R>(xs) = fold_left(xs, one<R or inferred Ring>(), mult) - //! product<> = product<integral_constant_tag<int>> - //! @endcode - //! - //! For numbers, this will just compute the product of the numbers in the - //! `xs` structure. - //! - //! @note - //! The elements of the structure are not actually required to be in the - //! same Ring, but it must be possible to perform `mult` on any two - //! adjacent elements of the structure, which requires each pair of - //! adjacent element to at least have a common Ring embedding. The - //! meaning of "adjacent" as used here is that two elements of the - //! structure `x` and `y` are adjacent if and only if they are adjacent - //! in the linearization of that structure, as documented by the Iterable - //! concept. - //! - //! @note - //! See the documentation for `sum` to understand why the Ring must - //! sometimes be specified explicitly. - //! - //! - //! Example - //! ------- - //! @include example/product.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto product = see documentation; -#else - template <typename T, typename = void> - struct product_impl : product_impl<T, when<true>> { }; - - template <typename R> - struct product_t; - - template <typename R = integral_constant_tag<int>> - constexpr product_t<R> product{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/range.hpp b/contrib/restricted/boost/boost/hana/fwd/range.hpp deleted file mode 100644 index 82d0f75232..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/range.hpp +++ /dev/null @@ -1,149 +0,0 @@ -/*! -@file -Forward declares `boost::hana::range`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_RANGE_HPP -#define BOOST_HANA_FWD_RANGE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! @ingroup group-datatypes - //! Compile-time half-open interval of `hana::integral_constant`s. - //! - //! A `range` represents a half-open interval of the form `[from, to)` - //! containing `hana::integral_constant`s of a given type. The `[from, to)` - //! notation represents the values starting at `from` (inclusively) up - //! to but excluding `from`. In other words, it is a bit like the list - //! `from, from+1, ..., to-1`. - //! - //! In particular, note that the bounds of the range can be any - //! `hana::integral_constant`s (negative numbers are allowed) and the - //! range does not have to start at zero. The only requirement is that - //! `from <= to`. - //! - //! @note - //! The representation of `hana::range` is implementation defined. In - //! particular, one should not take for granted the number and types - //! of template parameters. The proper way to create a `hana::range` - //! is to use `hana::range_c` or `hana::make_range`. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two ranges are equal if and only if they are both empty or they both - //! span the same interval. - //! @include example/range/comparable.cpp - //! - //! 2. `Foldable`\n - //! Folding a `range` is equivalent to folding a list of the - //! `integral_constant`s in the interval it spans. - //! @include example/range/foldable.cpp - //! - //! 3. `Iterable`\n - //! Iterating over a `range` is equivalent to iterating over a list of - //! the values it spans. In other words, iterating over the range - //! `[from, to)` is equivalent to iterating over a list containing - //! `from, from+1, from+2, ..., to-1`. Also note that `operator[]` can - //! be used in place of the `at` function. - //! @include example/range/iterable.cpp - //! - //! 4. `Searchable`\n - //! Searching a `range` is equivalent to searching a list of the values - //! in the range `[from, to)`, but it is much more compile-time efficient. - //! @include example/range/searchable.cpp - template <typename T, T from, T to> - struct range { - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::at` - template <typename N> - constexpr decltype(auto) operator[](N&& n); - }; -#else - template <typename T, T from, T to> - struct range; -#endif - - //! Tag representing a `hana::range`. - //! @relates hana::range - struct range_tag { }; - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Create a `hana::range` representing a half-open interval of - //! `integral_constant`s. - //! @relates hana::range - //! - //! Given two `IntegralConstant`s `from` and `to`, `make<range_tag>` - //! returns a `hana::range` representing the half-open interval of - //! `integral_constant`s `[from, to)`. `from` and `to` must form a - //! valid interval, which means that `from <= to` must be true. Otherwise, - //! a compilation error is triggered. Also note that if `from` and `to` - //! are `IntegralConstant`s with different underlying integral types, - //! the created range contains `integral_constant`s whose underlying - //! type is their common type. - //! - //! - //! Example - //! ------- - //! @include example/range/make.cpp - template <> - constexpr auto make<range_tag> = [](auto const& from, auto const& to) { - return range<implementation_defined>{implementation_defined}; - }; -#endif - - //! Alias to `make<range_tag>`; provided for convenience. - //! @relates hana::range - constexpr auto make_range = make<range_tag>; - - //! Shorthand to create a `hana::range` with the given bounds. - //! @relates hana::range - //! - //! This shorthand is provided for convenience only and it is equivalent - //! to `make_range`. Specifically, `range_c<T, from, to>` is such that - //! @code - //! range_c<T, from, to> == make_range(integral_c<T, from>, integral_c<T, to>) - //! @endcode - //! - //! - //! @tparam T - //! The underlying integral type of the `integral_constant`s in the - //! created range. - //! - //! @tparam from - //! The inclusive lower bound of the created range. - //! - //! @tparam to - //! The exclusive upper bound of the created range. - //! - //! - //! Example - //! ------- - //! @include example/range/range_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, T from, T to> - constexpr auto range_c = make_range(integral_c<T, from>, integral_c<T, to>); -#else - template <typename T, T from, T to> - constexpr range<T, from, to> range_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/remove.hpp b/contrib/restricted/boost/boost/hana/fwd/remove.hpp deleted file mode 100644 index 88254410a9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/remove.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Forward declares `boost::hana::remove`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REMOVE_HPP -#define BOOST_HANA_FWD_REMOVE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Remove all the elements of a monadic structure that are equal to some - //! value. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and a `value`, `remove` returns a new - //! monadic structure equal to `xs` without all its elements that are - //! equal to the given `value`. `remove` is equivalent to `remove_if` - //! with the `equal.to(value)` predicate, i.e. - //! @code - //! remove(xs, value) == remove_if(xs, equal.to(value)) - //! @endcode - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M` and a value of type `T`, the signature is - //! \f$ - //! \mathrm{remove} : M(T) \times T \to M(T) - //! \f$ - //! - //! @param xs - //! A monadic structure to remove some elements from. - //! - //! @param value - //! A value that is compared to every element `x` of the structure. - //! Elements of the structure that are equal to that value are removed - //! from the structure. This requires every element to be Comparable - //! with `value`. Furthermore, in the current version of the library, - //! comparing `value` with any element of the structure must yield a - //! compile-time Logical. - //! - //! - //! Example - //! ------- - //! @include example/remove.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto remove = [](auto&& xs, auto&& value) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct remove_impl : remove_impl<M, when<true>> { }; - - struct remove_t { - template <typename Xs, typename Value> - constexpr auto operator()(Xs&& xs, Value&& value) const; - }; - - constexpr remove_t remove{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REMOVE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/remove_at.hpp b/contrib/restricted/boost/boost/hana/fwd/remove_at.hpp deleted file mode 100644 index f997d6e4c5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/remove_at.hpp +++ /dev/null @@ -1,82 +0,0 @@ -/*! -@file -Forward declares `boost::hana::remove_at` and `boost::hana::remove_at_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REMOVE_AT_HPP -#define BOOST_HANA_FWD_REMOVE_AT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Remove the element at a given index from a sequence. - //! @ingroup group-Sequence - //! - //! `remove_at` returns a new sequence identical to the original, except - //! that the element at the given index is removed. Specifically, - //! `remove_at([x0, ..., xn-1, xn, xn+1, ..., xm], n)` is a new - //! sequence equivalent to `[x0, ..., xn-1, xn+1, ..., xm]`. - //! - //! @note - //! The behavior is undefined if the index is out of the bounds of the - //! sequence. - //! - //! - //! @param xs - //! A sequence from which an element is to be removed. - //! - //! @param n - //! An non-negative `IntegralConstant` representing the index of the - //! element to be removed from the sequence. The behavior is undefined - //! if that index is not in the bounds of the sequence. - //! - //! - //! Example - //! ------- - //! @include example/remove_at.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto remove_at = [](auto&& xs, auto const& n) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct remove_at_impl : remove_at_impl<S, when<true>> { }; - - struct remove_at_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - }; - - constexpr remove_at_t remove_at{}; -#endif - - //! Equivalent to `remove_at`; provided for convenience. - //! @ingroup group-Sequence - //! - //! - //! Example - //! ------- - //! @include example/remove_at_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto remove_at_c = [](auto&& xs) { - return hana::remove_at(forwarded(xs), hana::size_c<n>); - }; -#else - template <std::size_t n> - struct remove_at_c_t; - - template <std::size_t n> - constexpr remove_at_c_t<n> remove_at_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REMOVE_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/remove_if.hpp b/contrib/restricted/boost/boost/hana/fwd/remove_if.hpp deleted file mode 100644 index 590a6e195e..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/remove_if.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/*! -@file -Forward declares `boost::hana::remove_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REMOVE_IF_HPP -#define BOOST_HANA_FWD_REMOVE_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Remove all the elements of a monadic structure that satisfy some - //! predicate. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and a unary predicate, `remove_if` - //! returns a new monadic structure equal to `xs` without all its elements - //! that satisfy the predicate. This is equivalent to `filter` with a - //! negated predicate, i.e. - //! @code - //! remove_if(xs, predicate) == filter(xs, negated predicated) - //! @endcode - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M` and a predicate of type \f$ T \to Bool \f$ for - //! some compile-time Logical `Bool`, the signature is - //! \f$ - //! \mathrm{remove\_if} : M(T) \times (T \to Bool) \to M(T) - //! \f$ - //! - //! @param xs - //! A monadic structure to remove some elements from. - //! - //! @param predicate - //! A unary predicate called as `predicate(x)`, where `x` is an element - //! of the structure, and returning whether `x` should be removed from - //! the structure. In the current version of the library, `predicate` - //! must return a compile-time Logical. - //! - //! - //! Example - //! ------- - //! @include example/remove_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto remove_if = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct remove_if_impl : remove_if_impl<M, when<true>> { }; - - struct remove_if_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr remove_if_t remove_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REMOVE_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/remove_range.hpp b/contrib/restricted/boost/boost/hana/fwd/remove_range.hpp deleted file mode 100644 index 1645cce598..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/remove_range.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Forward declares `boost::hana::remove_range` and `boost::hana::remove_range_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REMOVE_RANGE_HPP -#define BOOST_HANA_FWD_REMOVE_RANGE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Remove the elements inside a given range of indices from a sequence. - //! @ingroup group-Sequence - //! - //! `remove_range` returns a new sequence identical to the original, - //! except that elements at indices in the provided range are removed. - //! Specifically, `remove_range([x0, ..., xn], from, to)` is a new - //! sequence equivalent to `[x0, ..., x_from-1, x_to, ..., xn]`. - //! - //! - //! @note - //! The behavior is undefined if the range contains any index out of the - //! bounds of the sequence. - //! - //! - //! @param xs - //! A sequence from which elements are removed. - //! - //! @param [from, to) - //! An half-open interval of `IntegralConstant`s representing the indices - //! of the elements to be removed from the sequence. The `IntegralConstant`s - //! in the half-open interval must be non-negative and in the bounds of - //! the sequence. The half-open interval must also be valid, meaning that - //! `from <= to`. - //! - //! - //! Example - //! ------- - //! @include example/remove_range.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto remove_range = [](auto&& xs, auto const& from, auto const& to) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct remove_range_impl : remove_range_impl<S, when<true>> { }; - - struct remove_range_t { - template <typename Xs, typename From, typename To> - constexpr auto operator()(Xs&& xs, From const& from, To const& to) const; - }; - - constexpr remove_range_t remove_range{}; -#endif - - //! Equivalent to `remove_range`; provided for convenience. - //! @ingroup group-Sequence - //! - //! - //! Example - //! ------- - //! @include example/remove_range_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t from, std::size_t to> - constexpr auto remove_range_c = [](auto&& xs) { - return hana::remove_range(forwarded(xs), hana::size_c<from>, hana::size_c<to>); - }; -#else - template <std::size_t from, std::size_t to> - struct remove_range_c_t; - - template <std::size_t from, std::size_t to> - constexpr remove_range_c_t<from, to> remove_range_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REMOVE_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/repeat.hpp b/contrib/restricted/boost/boost/hana/fwd/repeat.hpp deleted file mode 100644 index 0151b5c9e0..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/repeat.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Forward declares `boost::hana::repeat`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REPEAT_HPP -#define BOOST_HANA_FWD_REPEAT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Invokes a nullary function `n` times. - //! @ingroup group-IntegralConstant - //! - //! Given an `IntegralConstant` `n` and a nullary function `f`, - //! `repeat(n, f)` will call `f` `n` times. In particular, any - //! decent compiler should expand `repeat(n, f)` to - //! @code - //! f(); f(); ... f(); // n times total - //! @endcode - //! - //! - //! @param n - //! An `IntegralConstant` holding a non-negative value representing - //! the number of times `f` should be repeatedly invoked. - //! - //! @param f - //! A function to repeatedly invoke `n` times. `f` is allowed to have - //! side effects. - //! - //! - //! Example - //! ------- - //! @include example/repeat.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto repeat = [](auto const& n, auto&& f) -> void { - f(); f(); ... f(); // n times total - }; -#else - template <typename N, typename = void> - struct repeat_impl : repeat_impl<N, when<true>> { }; - - struct repeat_t { - template <typename N, typename F> - constexpr void operator()(N const& n, F&& f) const; - }; - - constexpr repeat_t repeat{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REPEAT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/replace.hpp b/contrib/restricted/boost/boost/hana/fwd/replace.hpp deleted file mode 100644 index 6edb858a7f..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/replace.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/*! -@file -Forward declares `boost::hana::replace`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REPLACE_HPP -#define BOOST_HANA_FWD_REPLACE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Replace all the elements of a structure that compare equal - //! to some `value` with some new fixed value. - //! @ingroup group-Functor - //! - //! - //! Signature - //! --------- - //! Given `F` a Functor and `U` a type that can be compared with `T`, - //! the signature is - //! \f$ - //! \mathtt{replace} : F(T) \times U \times T \to F(T) - //! \f$ - //! - //! @param xs - //! The structure to replace elements of. - //! - //! @param oldval - //! An object compared with each element of the structure. Elements - //! of the structure that compare equal to `oldval` are replaced - //! by `newval` in the new structure. - //! - //! @param newval - //! A value by which every element `x` of the structure that compares - //! equal to `oldval` is replaced. - //! - //! - //! Example - //! ------- - //! @include example/replace.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto replace = [](auto&& xs, auto&& oldval, auto&& newval) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct replace_impl : replace_impl<Xs, when<true>> { }; - - struct replace_t { - template <typename Xs, typename OldVal, typename NewVal> - constexpr auto operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const; - }; - - constexpr replace_t replace{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REPLACE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/replace_if.hpp b/contrib/restricted/boost/boost/hana/fwd/replace_if.hpp deleted file mode 100644 index 48d5b4c15c..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/replace_if.hpp +++ /dev/null @@ -1,63 +0,0 @@ -/*! -@file -Forward declares `boost::hana::replace_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REPLACE_IF_HPP -#define BOOST_HANA_FWD_REPLACE_IF_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Replace all the elements of a structure satisfying a `predicate` - //! with a fixed value. - //! @ingroup group-Functor - //! - //! - //! Signature - //! --------- - //! Given `F` a Functor and `Bool` a Logical, the signature is - //! \f$ - //! \mathtt{replace\_if} : F(T) \times (T \to Bool) \times T \to F(T) - //! \f$ - //! - //! @param xs - //! The structure to replace elements of. - //! - //! @param predicate - //! A function called as `predicate(x)` for element(s) `x` of the - //! structure and returning a `Logical` representing whether `x` - //! should be replaced by `value`. - //! - //! @param value - //! A value by which every element `x` of the structure for which - //! `predicate` returns a true-valued `Logical` is replaced. - //! - //! - //! Example - //! ------- - //! @include example/replace_if.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto replace_if = [](auto&& xs, auto&& predicate, auto&& value) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct replace_if_impl : replace_if_impl<Xs, when<true>> { }; - - struct replace_if_t { - template <typename Xs, typename Pred, typename Value> - constexpr auto operator()(Xs&& xs, Pred&& pred, Value&& value) const; - }; - - constexpr replace_if_t replace_if{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REPLACE_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/replicate.hpp b/contrib/restricted/boost/boost/hana/fwd/replicate.hpp deleted file mode 100644 index 4861adabae..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/replicate.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Forward declares `boost::hana::replicate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REPLICATE_HPP -#define BOOST_HANA_FWD_REPLICATE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Create a monadic structure by combining a lifted value with itself - //! `n` times. - //! @ingroup group-MonadPlus - //! - //! Given a value `x`, a non-negative `IntegralConstant` `n` and the tag - //! of a monadic structure `M`, `replicate` creates a new monadic structure - //! which is the result of combining `x` with itself `n` times inside the - //! monadic structure. In other words, `replicate` simply `lift`s `x` into - //! the monadic structure, and then combines that with itself `n` times: - //! @code - //! replicate<M>(x, n) == cycle(lift<M>(x), n) - //! @endcode - //! - //! If `n` is zero, then the identity of the `concat` operation is returned. - //! In the case of sequences, this corresponds to creating a new sequence - //! holding `n` copies of `x`. - //! - //! - //! Signature - //! --------- - //! Given an `IntegralConstant` `C` and MonadPlus `M`, the signature is - //! @f$ \mathtt{replicate}_M : T \times C \to M(T) @f$. - //! - //! @tparam M - //! The tag of the returned monadic structure. It must be a - //! model of the MonadPlus concept. - //! - //! @param x - //! The value to lift into a monadic structure and then combine with - //! itself. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of times to - //! combine `lift<M>(x)` with itself. If `n == 0`, `replicate` returns - //! `empty<M>()`. - //! - //! - //! Example - //! ------- - //! @include example/replicate.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto replicate = [](auto&& x, auto const& n) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct replicate_impl : replicate_impl<M, when<true>> { }; - - template <typename M> - struct replicate_t; - - template <typename M> - constexpr replicate_t<M> replicate{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REPLICATE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/reverse.hpp b/contrib/restricted/boost/boost/hana/fwd/reverse.hpp deleted file mode 100644 index b47b610bb8..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/reverse.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/*! -@file -Forward declares `boost::hana::reverse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REVERSE_HPP -#define BOOST_HANA_FWD_REVERSE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Reverse a sequence. - //! @ingroup group-Sequence - //! - //! Specifically, `reverse(xs)` is a new sequence containing the same - //! elements as `xs`, except in reverse order. - //! - //! - //! @param xs - //! The sequence to reverse. - //! - //! - //! Example - //! ------- - //! @include example/reverse.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto reverse = [](auto&& xs) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct reverse_impl : reverse_impl<S, when<true>> { }; - - struct reverse_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - }; - - constexpr reverse_t reverse{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REVERSE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/reverse_fold.hpp b/contrib/restricted/boost/boost/hana/fwd/reverse_fold.hpp deleted file mode 100644 index 607dd2dc4d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/reverse_fold.hpp +++ /dev/null @@ -1,84 +0,0 @@ -/*! -@file -Forward declares `boost::hana::reverse_fold`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_REVERSE_FOLD_HPP -#define BOOST_HANA_FWD_REVERSE_FOLD_HPP - -#include <boost/hana/config.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Equivalent to `reverse_fold` in Boost.Fusion and Boost.MPL. - //! @ingroup group-Foldable - //! - //! This method has the same semantics as `reverse_fold` in Boost.Fusion - //! and Boost.MPL, with the extension that an initial state is not - //! required. This method is equivalent to `fold_right`, except that - //! the accumulating function must take its arguments in reverse order, - //! to match the order used in Fusion. In other words, - //! @code - //! reverse_fold(sequence, state, f) == fold_right(sequence, state, flip(f)) - //! reverse_fold(sequence, f) == fold_right(sequence, flip(f)) - //! @endcode - //! - //! @note - //! This method is a convenience alias to `fold_right`. As an alias, - //! `reverse_fold` is not tag-dispatched on its own and `fold_right` - //! should be customized instead. - //! - //! - //! Signature - //! --------- - //! Given a `Foldable` `F` and an optional initial state of tag `S`, - //! the signatures for `reverse_fold` are - //! \f[ - //! \mathtt{reverse\_fold} : F(T) \times S \times (S \times T \to S) \to S - //! \f] - //! - //! for the variant with an initial state, and - //! \f[ - //! \mathtt{reverse\_fold} : F(T) \times (T \times T \to T) \to T - //! \f] - //! - //! for the variant without an initial state. - //! - //! @param xs - //! The structure to fold. - //! - //! @param state - //! The initial value used for folding. - //! - //! @param f - //! A binary function called as `f(state, x)`, where `state` is the - //! result accumulated so far and `x` is an element in the structure. - //! For reverse folds without an initial state, the function is called as - //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. - //! - //! - //! Example - //! ------- - //! @include example/reverse_fold.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto reverse_fold = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { - return fold_right(forwarded(xs), forwarded(state), flip(forwarded(f))); - }; -#else - struct reverse_fold_t { - template <typename Xs, typename S, typename F> - constexpr decltype(auto) operator()(Xs&& xs, S&& s, F&& f) const; - - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; - }; - - constexpr reverse_fold_t reverse_fold{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_REVERSE_FOLD_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/scan_left.hpp b/contrib/restricted/boost/boost/hana/fwd/scan_left.hpp deleted file mode 100644 index 2418196d32..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/scan_left.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Forward declares `boost::hana::scan_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SCAN_LEFT_HPP -#define BOOST_HANA_FWD_SCAN_LEFT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Fold a Sequence to the left and return a list containing the - //! successive reduction states. - //! @ingroup group-Sequence - //! - //! Like `fold_left`, `scan_left` reduces a sequence to a single value - //! using a binary operation. However, unlike `fold_left`, it builds up - //! a sequence of the intermediary results computed along the way and - //! returns that instead of only the final reduction state. Like - //! `fold_left`, `scan_left` can be used with or without an initial - //! reduction state. - //! - //! When the sequence is empty, two things may arise. If an initial state - //! was provided, a singleton list containing that state is returned. - //! Otherwise, if no initial state was provided, an empty list is - //! returned. In particular, unlike for `fold_left`, using `scan_left` - //! on an empty sequence without an initial state is not an error. - //! - //! More specifically, `scan_left([x1, ..., xn], state, f)` is a sequence - //! whose `i`th element is equivalent to `fold_left([x1, ..., xi], state, f)`. - //! The no-state variant is handled in an analogous way. For illustration, - //! consider this left fold on a short sequence: - //! @code - //! fold_left([x1, x2, x3], state, f) == f(f(f(state, x1), x2), x3) - //! @endcode - //! - //! The analogous sequence generated with `scan_left` will be - //! @code - //! scan_left([x1, x2, x3], state, f) == [ - //! state, - //! f(state, x1), - //! f(f(state, x1), x2), - //! f(f(f(state, x1), x2), x3) - //! ] - //! @endcode - //! - //! Similarly, consider this left fold (without an initial state) on - //! a short sequence: - //! @code - //! fold_left([x1, x2, x3, x4], f) == f(f(f(x1, x2), x3), x4) - //! @endcode - //! - //! The analogous sequence generated with `scan_left` will be - //! @code - //! scan_left([x1, x2, x3, x4], f) == [ - //! x1, - //! f(x1, x2), - //! f(f(x1, x2), x3), - //! f(f(f(x1, x2), x3), x4) - //! ] - //! @endcode - //! - //! @param xs - //! The sequence to scan from the left. - //! - //! @param state - //! The (optional) initial reduction state. - //! - //! @param f - //! A binary function called as `f(state, x)`, where `state` is the - //! result accumulated so far and `x` is an element in the sequence. - //! If no initial state is provided, `f` is called as `f(x1, x2)`, - //! where `x1` and `x2` are both elements of the sequence. - //! - //! - //! Example - //! ------- - //! @include example/scan_left.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto scan_left = [](auto&& xs[, auto&& state], auto const& f) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct scan_left_impl : scan_left_impl<S, when<true>> { }; - - struct scan_left_t { - template <typename Xs, typename State, typename F> - constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; - - template <typename Xs, typename F> - constexpr auto operator()(Xs&& xs, F const& f) const; - }; - - constexpr scan_left_t scan_left{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SCAN_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/scan_right.hpp b/contrib/restricted/boost/boost/hana/fwd/scan_right.hpp deleted file mode 100644 index c99cc911e9..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/scan_right.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Forward declares `boost::hana::scan_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SCAN_RIGHT_HPP -#define BOOST_HANA_FWD_SCAN_RIGHT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Fold a Sequence to the right and return a list containing the - //! successive reduction states. - //! @ingroup group-Sequence - //! - //! Like `fold_right`, `scan_right` reduces a sequence to a single value - //! using a binary operation. However, unlike `fold_right`, it builds up - //! a sequence of the intermediary results computed along the way and - //! returns that instead of only the final reduction state. Like - //! `fold_right`, `scan_right` can be used with or without an initial - //! reduction state. - //! - //! When the sequence is empty, two things may arise. If an initial state - //! was provided, a singleton list containing that state is returned. - //! Otherwise, if no initial state was provided, an empty list is - //! returned. In particular, unlike for `fold_right`, using `scan_right` - //! on an empty sequence without an initial state is not an error. - //! - //! More specifically, `scan_right([x1, ..., xn], state, f)` is a sequence - //! whose `i`th element is equivalent to `fold_right([x1, ..., xi], state, f)`. - //! The no-state variant is handled in an analogous way. For illustration, - //! consider this right fold on a short sequence: - //! @code - //! fold_right([x1, x2, x3], state, f) == f(x1, f(x2, f(x3, state))) - //! @endcode - //! - //! The analogous sequence generated with `scan_right` will be - //! @code - //! scan_right([x1, x2, x3], state, f) == [ - //! f(x1, f(x2, f(x3, state))), - //! f(x2, f(x3, state)), - //! f(x3, state), - //! state - //! ] - //! @endcode - //! - //! Similarly, consider this right fold (without an initial state) on - //! a short sequence: - //! @code - //! fold_right([x1, x2, x3, x4], f) == f(x1, f(x2, f(x3, x4))) - //! @endcode - //! - //! The analogous sequence generated with `scan_right` will be - //! @code - //! scan_right([x1, x2, x3, x4], f) == [ - //! f(x1, f(x2, f(x3, x4))), - //! f(x2, f(x3, x4)), - //! f(x3, x4), - //! x4 - //! ] - //! @endcode - //! - //! @param xs - //! The sequence to scan from the right. - //! - //! @param state - //! The (optional) initial reduction state. - //! - //! @param f - //! A binary function called as `f(x, state)`, where `state` is the - //! result accumulated so far and `x` is an element in the sequence. - //! When no initial state is provided, `f` is called as `f(x1, x2)`, - //! where `x1` and `x2` are elements of the sequence. - //! - //! - //! Example - //! ------- - //! @include example/scan_right.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto scan_right = [](auto&& xs[, auto&& state], auto const& f) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct scan_right_impl : scan_right_impl<S, when<true>> { }; - - struct scan_right_t { - template <typename Xs, typename State, typename F> - constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; - - template <typename Xs, typename F> - constexpr auto operator()(Xs&& xs, F const& f) const; - }; - - constexpr scan_right_t scan_right{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SCAN_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/second.hpp b/contrib/restricted/boost/boost/hana/fwd/second.hpp deleted file mode 100644 index 6dc4623b79..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/second.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Forward declares `boost::hana::second`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SECOND_HPP -#define BOOST_HANA_FWD_SECOND_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the second element of a pair. - //! @ingroup group-Product - //! - //! Note that if the `Product` actually stores the elements it contains, - //! `hana::second` is required to return a lvalue reference, a lvalue - //! reference to const or a rvalue reference to the second element, where - //! the type of reference must match that of the pair passed to `second`. - //! If the `Product` does not store the elements it contains (i.e. it - //! generates them on demand), this requirement is dropped. - //! - //! Example - //! ------- - //! @include example/second.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto second = [](auto&& product) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename P, typename = void> - struct second_impl : second_impl<P, when<true>> { }; - - struct second_t { - template <typename Pair> - constexpr decltype(auto) operator()(Pair&& pair) const; - }; - - constexpr second_t second{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SECOND_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/set.hpp b/contrib/restricted/boost/boost/hana/fwd/set.hpp deleted file mode 100644 index 7312854782..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/set.hpp +++ /dev/null @@ -1,297 +0,0 @@ -/*! -@file -Forward declares `boost::hana::set`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SET_HPP -#define BOOST_HANA_FWD_SET_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/erase_key.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! Basic unordered container requiring unique, `Comparable` and - //! `Hashable` keys. - //! - //! A set is an unordered container that can hold heterogeneous keys. - //! A set requires (and ensures) that no duplicates are present when - //! inserting new keys. - //! - //! @note - //! The actual representation of a `hana::set` is implementation-defined. - //! In particular, one should not take for granted the order of the - //! template parameters and the presence of any additional constructors - //! or assignment operators than what is documented. The canonical way of - //! creating a `hana::set` is through `hana::make_set`. - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two sets are equal iff they contain the same elements, regardless of - //! the order. - //! @include example/set/comparable.cpp - //! - //! 2. Foldable\n - //! Folding a set is equivalent to folding the sequence of its values. - //! However, note that the values are not required to be in any specific - //! order, so using the folds provided here with an operation that is not - //! both commutative and associative will yield non-deterministic behavior. - //! @include example/set/foldable.cpp - //! - //! 3. Searchable\n - //! The elements in a set act as both its keys and its values. Since the - //! elements of a set are unique, searching for an element will return - //! either the only element which is equal to the searched value, or - //! `nothing`. Also note that `operator[]` can be used instead of the - //! `at_key` function. - //! @include example/set/searchable.cpp - //! - //! - //! Conversion from any `Foldable` - //! ------------------------------ - //! Any `Foldable` structure can be converted into a `hana::set` with - //! `to<set_tag>`. The elements of the structure must all be compile-time - //! `Comparable`. If the structure contains duplicate elements, only - //! the first occurence will appear in the resulting set. More - //! specifically, conversion from a `Foldable` is equivalent to - //! @code - //! to<set_tag>(xs) == fold_left(xs, make_set(), insert) - //! @endcode - //! - //! __Example__ - //! @include example/set/to.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename implementation_defined> - struct set { - //! Default-construct a set. This constructor only exists when all the - //! elements of the set are default-constructible. - constexpr set() = default; - - //! Copy-construct a set from another set. This constructor only - //! exists when all the elements of the set are copy-constructible. - constexpr set(set const& other) = default; - - //! Move-construct a set from another set. This constructor only - //! exists when all the elements of the set are move-constructible. - constexpr set(set&& other) = default; - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::at_key` - template <typename Key> - constexpr decltype(auto) operator[](Key&& key); - }; -#else - template <typename ...Xs> - struct set; -#endif - - //! Tag representing the `hana::set` container. - //! @relates hana::set - struct set_tag { }; - - //! Function object for creating a `hana::set`. - //! @relates hana::set - //! - //! Given zero or more values `xs...`, `make<set_tag>` returns a `set` - //! containing those values. The values must all be compile-time - //! `Comparable`, and no duplicate values may be provided. To create - //! a `set` from a sequence with possible duplicates, use `to<set_tag>` - //! instead. - //! - //! - //! Example - //! ------- - //! @include example/set/make.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <> - constexpr auto make<set_tag> = [](auto&& ...xs) { - return set<implementation_defined>{forwarded(xs)...}; - }; -#endif - - //! Equivalent to `make<set_tag>`; provided for convenience. - //! @relates hana::set - //! - //! - //! Example - //! ------- - //! @include example/set/make.cpp - constexpr auto make_set = make<set_tag>; - - //! Insert an element in a `hana::set`. - //! @relates hana::set - //! - //! If the set already contains an element that compares equal, then - //! nothing is done and the set is returned as is. - //! - //! - //! @param set - //! The set in which to insert a value. - //! - //! @param element - //! The value to insert. It must be compile-time `Comparable`. - //! - //! - //! Example - //! ------- - //! @include example/set/insert.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto insert = [](auto&& set, auto&& element) { - return tag-dispatched; - }; -#endif - - //! Remove an element from a `hana::set`. - //! @relates hana::set - //! - //! Returns a new set containing all the elements of the original, - //! except the one comparing `equal` to the given element. If the set - //! does not contain such an element, a new set equal to the original - //! set is returned. - //! - //! - //! @param set - //! The set in which to remove a value. - //! - //! @param element - //! The value to remove. It must be compile-time `Comparable`. - //! - //! - //! Example - //! ------- - //! @include example/set/erase_key.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto erase_key = [](auto&& set, auto&& element) { - return tag-dispatched; - }; -#endif - - //! Returns the union of two sets. - //! @relates hana::set - //! - //! Given two sets `xs` and `ys`, `union_(xs, ys)` is a new set containing - //! all the elements of `xs` and all the elements of `ys`, without - //! duplicates. For any object `x`, the following holds: `x` is in - //! `hana::union_(xs, ys)` if and only if `x` is in `xs` or `x` is in `ys`. - //! - //! - //! @param xs, ys - //! Two sets to compute the union of. - //! - //! - //! Example - //! ------- - //! @include example/set/union.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto union_ = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - //! Returns the intersection of two sets. - //! @relates hana::set - //! - //! Given two sets `xs` and `ys`, `intersection(xs, ys)` is a new set - //! containing exactly those elements that are present both in `xs` and - //! in `ys`. - //! In other words, the following holds for any object `x`: - //! @code - //! x ^in^ intersection(xs, ys) if and only if x ^in^ xs && x ^in^ ys - //! @endcode - //! - //! - //! @param xs, ys - //! Two sets to intersect. - //! - //! - //! Example - //! ------- - //! @include example/set/intersection.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto intersection = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - //! Equivalent to `to<set_tag>`; provided for convenience. - //! @relates hana::set - constexpr auto to_set = to<set_tag>; - - //! Returns the set-theoretic difference of two sets. - //! @relates hana::set - //! - //! Given two sets `xs` and `ys`, `difference(xs, ys)` is a new set - //! containing all the elements of `xs` that are _not_ contained in `ys`. - //! For any object `x`, the following holds: - //! @code - //! x ^in^ difference(xs, ys) if and only if x ^in^ xs && !(x ^in^ ys) - //! @endcode - //! - //! - //! This operation is not commutative, i.e. `difference(xs, ys)` is not - //! necessarily the same as `difference(ys, xs)`. Indeed, consider the - //! case where `xs` is empty and `ys` isn't. Then, `difference(xs, ys)` - //! is empty but `difference(ys, xs)` is equal to `ys`. For the symmetric - //! version of this operation, see `symmetric_difference`. - //! - //! - //! @param xs - //! A set param to remove values from. - //! - //! @param ys - //! The set whose values are removed from `xs`. - //! - //! - //! Example - //! ------- - //! @include example/set/difference.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto difference = [](auto&& xs, auto&& ys) { - return tag-dispatched; -}; -#endif - - //! Returns the symmetric set-theoretic difference of two sets. - //! @relates hana::set - //! - //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new - //! set containing all the elements of `xs` that are not contained in `ys`, - //! and all the elements of `ys` that are not contained in `xs`. The - //! symmetric difference of two sets satisfies the following: - //! @code - //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) - //! @endcode - //! - //! - //! @param xs, ys - //! Two sets to compute the symmetric difference of. - //! - //! - //! Example - //! ------- - //! @include example/set/symmetric_difference.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED -constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { - return tag-dispatched; - }; -#endif - - -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SET_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/size.hpp b/contrib/restricted/boost/boost/hana/fwd/size.hpp deleted file mode 100644 index 8999b91413..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/size.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/*! -@file -Forward declares `boost::hana::size`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SIZE_HPP -#define BOOST_HANA_FWD_SIZE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/length.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Equivalent to `length`; provided for consistency with the - //! standard library. - //! @ingroup group-Foldable - //! - //! This method is an alias to `length` provided for convenience and - //! consistency with the standard library. As an alias, `size` is not - //! tag-dispatched on its own and `length` should be customized instead. - //! - //! - //! Example - //! ------- - //! @include example/size.cpp - constexpr auto size = hana::length; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SIZE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/slice.hpp b/contrib/restricted/boost/boost/hana/fwd/slice.hpp deleted file mode 100644 index f8dfafc02d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/slice.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Forward declares `boost::hana::slice` and `boost::hana::slice_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SLICE_HPP -#define BOOST_HANA_FWD_SLICE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Extract the elements of a `Sequence` at the given indices. - //! @ingroup group-Sequence - //! - //! Given an arbitrary sequence of `indices`, `slice` returns a new - //! sequence of the elements of the original sequence that appear at - //! those indices. In other words, - //! @code - //! slice([x1, ..., xn], [i1, ..., ik]) == [x_i1, ..., x_ik] - //! @endcode - //! - //! The indices do not have to be ordered or contiguous in any particular - //! way, but they must not be out of the bounds of the sequence. It is - //! also possible to specify the same index multiple times, in which case - //! the element at this index will be repeatedly included in the resulting - //! sequence. - //! - //! - //! @param xs - //! The sequence from which a subsequence is extracted. - //! - //! @param indices - //! A compile-time `Foldable` containing non-negative `IntegralConstant`s - //! representing the indices. The indices are 0-based, and they must all - //! be in bounds of the `xs` sequence. Note that any `Foldable` will - //! really do (no need for an `Iterable`, for example); the linearization - //! of the `indices` is used to determine the order of the elements - //! included in the slice. - //! - //! - //! Example - //! ------- - //! @include example/slice.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto slice = [](auto&& xs, auto&& indices) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct slice_impl : slice_impl<S, when<true>> { }; - - struct slice_t { - template <typename Xs, typename Indices> - constexpr auto operator()(Xs&& xs, Indices&& indices) const; - }; - - constexpr slice_t slice{}; -#endif - - //! Shorthand to `slice` a contiguous range of elements. - //! @ingroup group-Sequence - //! - //! `slice_c` is simply a shorthand to slice a contiguous range of - //! elements. In particular, `slice_c<from, to>(xs)` is equivalent to - //! `slice(xs, range_c<std::size_t, from, to>)`, which simply slices - //! all the elements of `xs` contained in the half-open interval - //! delimited by `[from, to)`. Like for `slice`, the indices used with - //! `slice_c` are 0-based and they must be in the bounds of the sequence - //! being sliced. - //! - //! - //! @tparam from - //! The index of the first element in the slice. - //! - //! @tparam to - //! One-past the index of the last element in the slice. It must hold - //! that `from <= to`. - //! - //! - //! Example - //! ------- - //! @include example/slice_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t from, std::size_t to> - constexpr auto slice_c = [](auto&& xs) { - return hana::slice(forwarded(xs), hana::range_c<std::size_t, from, to>); - }; -#else - template <std::size_t from, std::size_t to> - struct slice_c_t; - - template <std::size_t from, std::size_t to> - constexpr slice_c_t<from, to> slice_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SLICE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/sort.hpp b/contrib/restricted/boost/boost/hana/fwd/sort.hpp deleted file mode 100644 index c0d45aee23..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/sort.hpp +++ /dev/null @@ -1,103 +0,0 @@ -/*! -@file -Forward declares `boost::hana::sort`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SORT_HPP -#define BOOST_HANA_FWD_SORT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Sort a sequence, optionally based on a custom `predicate`. - //! @ingroup group-Sequence - //! - //! Given a Sequence and an optional predicate (by default `less`), `sort` - //! returns a new sequence containing the same elements as the original, - //! except they are ordered in such a way that if `x` comes before `y` in - //! the sequence, then either `predicate(x, y)` is true, or both - //! `predicate(x, y)` and `predicate(y, x)` are false. - //! - //! Also note that the sort is guaranteed to be stable. Hence, if `x` - //! comes before `y` in the original sequence and both `predicate(x, y)` - //! and `predicate(y, x)` are false, then `x` will come before `y` in the - //! resulting sequence. - //! - //! If no predicate is provided, the elements in the sequence must all be - //! compile-time `Orderable`. - //! - //! Signature - //! --------- - //! Given a `Sequence` `S(T)`, a boolean `IntegralConstant` `Bool` and a - //! binary predicate \f$ T \times T \to Bool \f$, `sort` has the following - //! signatures. For the variant with a provided predicate, - //! \f[ - //! \mathtt{sort} : S(T) \times (T \times T \to Bool) \to S(T) - //! \f] - //! - //! for the variant without a custom predicate, `T` is required to be - //! `Orderable`. The signature is then - //! \f[ - //! \mathtt{sort} : S(T) \to S(T) - //! \f] - //! - //! @param xs - //! The sequence to sort. - //! - //! @param predicate - //! A function called as `predicate(x, y)` for two elements `x` and `y` of - //! the sequence, and returning a boolean `IntegralConstant` representing - //! whether `x` is to be considered _less_ than `y`, i.e. whether `x` should - //! appear _before_ `y` in the resulting sequence. More specifically, - //! `predicate` must define a [strict weak ordering][1] on the elements - //! of the sequence. When the predicate is not specified, this defaults - //! to `less`. In the current version of the library, the predicate has - //! to return an `IntegralConstant` holding a value convertible to a `bool`. - //! - //! - //! Syntactic sugar (`sort.by`) - //! --------------------------- - //! `sort` can be called in a third way, which provides a nice syntax - //! especially when working with the `ordering` combinator: - //! @code - //! sort.by(predicate, xs) == sort(xs, predicate) - //! sort.by(predicate) == sort(-, predicate) - //! @endcode - //! - //! where `sort(-, predicate)` denotes the partial application of - //! `sort` to `predicate`. - //! - //! - //! Example - //! ------- - //! @include example/sort.cpp - //! - //! [1]: http://en.wikipedia.org/wiki/Strict_weak_ordering -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto sort = [](auto&& xs[, auto&& predicate]) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct sort_impl : sort_impl<S, when<true>> { }; - - struct sort_t : detail::nested_by<sort_t> { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - - template <typename Xs, typename Predicate> - constexpr auto operator()(Xs&& xs, Predicate&& pred) const; - }; - - constexpr sort_t sort{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SORT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/span.hpp b/contrib/restricted/boost/boost/hana/fwd/span.hpp deleted file mode 100644 index 047b2bc174..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/span.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Forward declares `boost::hana::span`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SPAN_HPP -#define BOOST_HANA_FWD_SPAN_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns a `Product` containing the longest prefix of a sequence - //! satisfying a predicate, and the rest of the sequence. - //! @ingroup group-Sequence - //! - //! The first component of the returned `Product` is a sequence for which - //! all elements satisfy the given predicate. The second component of the - //! returned `Product` is a sequence containing the remainder of the - //! argument. Both or either sequences may be empty, depending on the - //! input argument. More specifically, - //! @code - //! span(xs, predicate) == make_pair(take_while(xs, predicate), - //! drop_while(xs, predicate)) - //! @endcode - //! except that `make_pair` may be an arbitrary `Product`. - //! - //! - //! Signature - //! --------- - //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a predicate - //! \f$ T \to Bool \f$, `span` has the following signature: - //! \f[ - //! \mathtt{span} : S(T) \times (T \to Bool) \to S(T) \times S(T) - //! \f] - //! - //! @param xs - //! The sequence to break into two parts. - //! - //! @param predicate - //! A function called as `predicate(x)`, where `x` is an element of the - //! sequence, and returning a `Logical. In the current implementation of - //! the library, `predicate` has to return a compile-time `Logical`. - //! - //! - //! Syntactic sugar (`span.by`) - //! --------------------------- - //! `span` can be called in an alternate way, which provides a nice syntax - //! in some cases where the predicate is short: - //! @code - //! span.by(predicate, xs) == span(xs, predicate) - //! span.by(predicate) == span(-, predicate) - //! @endcode - //! - //! where `span(-, predicate)` denotes the partial application of - //! `span` to `predicate`. - //! - //! - //! Example - //! ------- - //! @include example/span.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto span = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct span_impl : span_impl<S, when<true>> { }; - - struct span_t : detail::nested_by<span_t> { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr span_t span{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SPAN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/string.hpp b/contrib/restricted/boost/boost/hana/fwd/string.hpp deleted file mode 100644 index 80c1622500..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/string.hpp +++ /dev/null @@ -1,271 +0,0 @@ -/*! -@file -Forward declares `boost::hana::string`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_STRING_HPP -#define BOOST_HANA_FWD_STRING_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/to.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! @ingroup group-datatypes - //! Compile-time string. - //! - //! Conceptually, a `hana::string` is like a tuple holding - //! `integral_constant`s of underlying type `char`. However, the - //! interface of `hana::string` is not as rich as that of a tuple, - //! because a string can only hold compile-time characters as opposed - //! to any kind of object. - //! - //! Compile-time strings are used for simple purposes like being keys in a - //! `hana::map` or tagging the members of a `Struct`. However, you might - //! find that `hana::string` does not provide enough functionality to be - //! used as a full-blown compile-time string implementation (e.g. regexp - //! matching or substring finding). Indeed, providing a comprehensive - //! string interface is a lot of job, and it is out of the scope of the - //! library for the time being. - //! - //! - //! @note - //! The representation of `hana::string` is implementation-defined. - //! In particular, one should not take for granted that the template - //! parameters are `char`s. The proper way to access the contents of - //! a `hana::string` as character constants is to use `hana::unpack`, - //! `.c_str()` or `hana::to<char const*>`, as documented below. - //! - //! - //! Modeled concepts - //! ---------------- - //! For most purposes, a `hana::string` is functionally equivalent to a - //! tuple holding `Constant`s of underlying type `char`. - //! - //! 1. `Comparable`\n - //! Two strings are equal if and only if they have the same number of - //! characters and characters at corresponding indices are equal. - //! @include example/string/comparable.cpp - //! - //! 2. `Orderable`\n - //! The total order implemented for `Orderable` is the usual - //! lexicographical comparison of strings. - //! @include example/string/orderable.cpp - //! - //! 3. `Monoid`\n - //! Strings form a monoid under concatenation, with the neutral element - //! being the empty string. - //! @include example/string/monoid.cpp - //! - //! 4. `Foldable`\n - //! Folding a string is equivalent to folding the sequence of its - //! characters. - //! @include example/string/foldable.cpp - //! - //! 5. `Iterable`\n - //! Iterating over a string is equivalent to iterating over the sequence - //! of its characters. Also note that `operator[]` can be used instead of - //! the `at` function. - //! @include example/string/iterable.cpp - //! - //! 6. `Searchable`\n - //! Searching through a string is equivalent to searching through the - //! sequence of its characters. - //! @include example/string/searchable.cpp - //! - //! 7. `Hashable`\n - //! The hash of a compile-time string is a type uniquely representing - //! that string. - //! @include example/string/hashable.cpp - //! - //! - //! Conversion to `char const*` - //! --------------------------- - //! A `hana::string` can be converted to a `constexpr` null-delimited - //! string of type `char const*` by using the `c_str()` method or - //! `hana::to<char const*>`. This makes it easy to turn a compile-time - //! string into a runtime string. However, note that this conversion is - //! not an embedding, because `char const*` does not model the same - //! concepts as `hana::string` does. - //! @include example/string/to.cpp - //! - //! Conversion from any Constant holding a `char const*` - //! ---------------------------------------------------- - //! A `hana::string` can be created from any `Constant` whose underlying - //! value is convertible to a `char const*` by using `hana::to`. The - //! contents of the `char const*` are used to build the content of the - //! `hana::string`. - //! @include example/string/from_c_str.cpp - //! - //! Rationale for `hana::string` not being a `Constant` itself - //! ---------------------------------------------------------- - //! The underlying type held by a `hana::string` could be either `char const*` - //! or some other constexpr-enabled string-like container. In the first case, - //! `hana::string` can not be a `Constant` because the models of several - //! concepts would not be respected by the underlying type, causing `value` - //! not to be structure-preserving. Providing an underlying value of - //! constexpr-enabled string-like container type like `std::string_view` - //! would be great, but that's a bit complicated for the time being. - template <typename implementation_defined> - struct string { - // Default-construct a `hana::string`; no-op since `hana::string` is stateless. - constexpr string() = default; - - // Copy-construct a `hana::string`; no-op since `hana::string` is stateless. - constexpr string(string const&) = default; - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::less` - template <typename X, typename Y> - friend constexpr auto operator<(X&& x, Y&& y); - - //! Equivalent to `hana::greater` - template <typename X, typename Y> - friend constexpr auto operator>(X&& x, Y&& y); - - //! Equivalent to `hana::less_equal` - template <typename X, typename Y> - friend constexpr auto operator<=(X&& x, Y&& y); - - //! Equivalent to `hana::greater_equal` - template <typename X, typename Y> - friend constexpr auto operator>=(X&& x, Y&& y); - - //! Performs concatenation; equivalent to `hana::plus` - template <typename X, typename Y> - friend constexpr auto operator+(X&& x, Y&& y); - - //! Equivalent to `hana::at` - template <typename N> - constexpr decltype(auto) operator[](N&& n); - - //! Returns a null-delimited C-style string. - static constexpr char const* c_str(); - }; -#else - template <char ...s> - struct string; -#endif - - //! Tag representing a compile-time string. - //! @relates hana::string - struct string_tag { }; - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Create a compile-time `hana::string` from a parameter pack of `char` - //! `integral_constant`s. - //! @relates hana::string - //! - //! Given zero or more `integral_constant`s of underlying type `char`, - //! `make<string_tag>` creates a `hana::string` containing those characters. - //! This is provided mostly for consistency with the rest of the library, - //! as `hana::string_c` is more convenient to use in most cases. - //! - //! - //! Example - //! ------- - //! @include example/string/make.cpp - template <> - constexpr auto make<string_tag> = [](auto&& ...chars) { - return string<implementation_defined>{}; - }; -#endif - - //! Alias to `make<string_tag>`; provided for convenience. - //! @relates hana::string - constexpr auto make_string = make<string_tag>; - - //! Equivalent to `to<string_tag>`; provided for convenience. - //! @relates hana::string - constexpr auto to_string = to<string_tag>; - - //! Create a compile-time string from a parameter pack of characters. - //! @relates hana::string - //! - //! - //! Example - //! ------- - //! @include example/string/string_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <char ...s> - constexpr string<implementation_defined> string_c{}; -#else - template <char ...s> - constexpr string<s...> string_c{}; -#endif - - //! Create a compile-time string from a string literal. - //! @relates hana::string - //! - //! This macro is a more convenient alternative to `string_c` for creating - //! compile-time strings. However, since this macro uses a lambda - //! internally, it can't be used in an unevaluated context. - //! - //! - //! Example - //! ------- - //! @include example/string/macro.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - auto BOOST_HANA_STRING(s) = see documentation; - #define BOOST_HANA_STRING(s) see documentation - - // Note: - // The trick above seems to exploit a bug in Doxygen, which makes the - // BOOST_HANA_STRING macro appear in the related objects of hana::string - // (as we want it to). -#else - // defined in <boost/hana/string.hpp> -#endif - -#ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL - namespace literals { - //! Creates a compile-time string from a string literal. - //! @relatesalso boost::hana::string - //! - //! The string literal is parsed at compile-time and the result is - //! returned as a `hana::string`. This feature is an extension that - //! is disabled by default; see below for details. - //! - //! @note - //! Only narrow string literals are supported right now; support for - //! fancier types of string literals like wide or UTF-XX might be - //! added in the future if there is a demand for it. See [this issue] - //! [Hana.issue80] if you need this. - //! - //! @warning - //! This user-defined literal is an extension which requires a special - //! string literal operator that is not part of the standard yet. - //! That operator is supported by both Clang and GCC, and several - //! proposals were made for it to enter C++17. However, since it is - //! not standard, it is disabled by default and defining the - //! `BOOST_HANA_CONFIG_ENABLE_STRING_UDL` config macro is required - //! to get this operator. Hence, if you want to stay safe, just use - //! the `BOOST_HANA_STRING` macro instead. If you want to be fast and - //! furious (I do), define `BOOST_HANA_CONFIG_ENABLE_STRING_UDL`. - //! - //! - //! Example - //! ------- - //! @include example/string/literal.cpp - //! - //! [Hana.issue80]: https://github.com/boostorg/hana/issues/80 - template <typename CharT, CharT ...s> - constexpr auto operator"" _s(); - } -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_STRING_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/suffix.hpp b/contrib/restricted/boost/boost/hana/fwd/suffix.hpp deleted file mode 100644 index 331854fe5d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/suffix.hpp +++ /dev/null @@ -1,72 +0,0 @@ -/*! -@file -Forward declares `boost::hana::suffix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SUFFIX_HPP -#define BOOST_HANA_FWD_SUFFIX_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Inserts a value after each element of a monadic structure. - //! @ingroup group-MonadPlus - //! - //! Given a monadic structure `xs` and a value `z` (called the suffix), - //! `suffix` returns a new monadic structure such that - //! @code - //! suffix(xs, z) == flatten(transform(xs, [](auto x) { - //! return concat(lift<M>(x), lift<M>(z)); - //! })) - //! @endcode - //! - //! For sequences, this simply corresponds to inserting the suffix after - //! each element of the sequence. For example, given a sequence - //! `[x1, ..., xn]`, `suffix` will return - //! @code - //! [x1, z, x2, z, ..., xn, z] - //! @endcode - //! As explained above, this can be generalized to other MonadPlus models, - //! with various levels of interest. - //! - //! - //! Signature - //! --------- - //! Given a MonadPlus `M`, the signature is - //! @f$ \mathtt{suffix} : M(T) \times T \to M(T) @f$. - //! - //! @param xs - //! A monadic structure. - //! - //! @param sfx - //! A value (the suffix) to insert after each element of a monadic - //! structure. - //! - //! - //! Example - //! ------- - //! @include example/suffix.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto suffix = [](auto&& xs, auto&& sfx) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct suffix_impl : suffix_impl<M, when<true>> { }; - - struct suffix_t { - template <typename Xs, typename Sfx> - constexpr auto operator()(Xs&& xs, Sfx&& sfx) const; - }; - - constexpr suffix_t suffix{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SUFFIX_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/sum.hpp b/contrib/restricted/boost/boost/hana/fwd/sum.hpp deleted file mode 100644 index c565ecd7f7..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/sum.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/*! -@file -Forward declares `boost::hana::sum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SUM_HPP -#define BOOST_HANA_FWD_SUM_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/fwd/integral_constant.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Compute the sum of the numbers of a structure. - //! @ingroup group-Foldable - //! - //! More generally, `sum` will take any foldable structure containing - //! objects forming a Monoid and reduce them using the Monoid's binary - //! operation. The initial state for folding is the identity of the - //! Monoid. It is sometimes necessary to specify the Monoid to use; - //! this is possible by using `sum<M>`. If no Monoid is specified, - //! the structure will use the Monoid formed by the elements it contains - //! (if it knows it), or `integral_constant_tag<int>` otherwise. Hence, - //! @code - //! sum<M>(xs) = fold_left(xs, zero<M or inferred Monoid>(), plus) - //! sum<> = sum<integral_constant_tag<int>> - //! @endcode - //! - //! For numbers, this will just compute the sum of the numbers in the - //! `xs` structure. - //! - //! - //! @note - //! The elements of the structure are not actually required to be in the - //! same Monoid, but it must be possible to perform `plus` on any two - //! adjacent elements of the structure, which requires each pair of - //! adjacent element to at least have a common Monoid embedding. The - //! meaning of "adjacent" as used here is that two elements of the - //! structure `x` and `y` are adjacent if and only if they are adjacent - //! in the linearization of that structure, as documented by the Iterable - //! concept. - //! - //! - //! Why must we sometimes specify the `Monoid` by using `sum<M>`? - //! ------------------------------------------------------------- - //! This is because sequence tags like `tuple_tag` are not parameterized - //! (by design). Hence, we do not know what kind of objects are in the - //! sequence, so we can't know a `0` value of which type should be - //! returned when the sequence is empty. Therefore, the type of the - //! `0` to return in the empty case must be specified explicitly. Other - //! foldable structures like `hana::range`s will ignore the suggested - //! Monoid because they know the tag of the objects they contain. This - //! inconsistent behavior is a limitation of the current design with - //! non-parameterized tags, but we have no good solution for now. - //! - //! - //! Example - //! ------- - //! @include example/sum.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto sum = see documentation; -#else - template <typename T, typename = void> - struct sum_impl : sum_impl<T, when<true>> { }; - - template <typename M> - struct sum_t; - - template <typename M = integral_constant_tag<int>> - constexpr sum_t<M> sum{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SUM_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/symmetric_difference.hpp b/contrib/restricted/boost/boost/hana/fwd/symmetric_difference.hpp deleted file mode 100644 index 2253f167eb..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/symmetric_difference.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Forward declares `boost::hana::symmetric_difference`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP -#define BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename S, typename = void> - struct symmetric_difference_impl : symmetric_difference_impl<S, when<true>> { }; - //! @endcond - - struct symmetric_difference_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&&, Ys&&) const; - }; - - constexpr symmetric_difference_t symmetric_difference{}; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/take_back.hpp b/contrib/restricted/boost/boost/hana/fwd/take_back.hpp deleted file mode 100644 index 5ba1cf932f..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/take_back.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Forward declares `boost::hana::take_back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TAKE_BACK_HPP -#define BOOST_HANA_FWD_TAKE_BACK_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the last `n` elements of a sequence, or the whole sequence - //! if the sequence has less than `n` elements. - //! @ingroup group-Sequence - //! - //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_back(xs, n)` - //! is a new sequence containing the last `n` elements of `xs`, in the - //! same order. If `length(xs) <= n`, the whole sequence is returned and - //! no error is triggered. - //! - //! - //! @param xs - //! The sequence to take the elements from. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of elements - //! to keep in the resulting sequence. - //! - //! - //! Example - //! ------- - //! @include example/take_back.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto take_back = [](auto&& xs, auto const& n) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct take_back_impl : take_back_impl<S, when<true>> { }; - - struct take_back_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - }; - - constexpr take_back_t take_back{}; -#endif - - //! Equivalent to `take_back`; provided for convenience. - //! @ingroup group-Sequence - //! - //! - //! Example - //! ------- - //! @include example/take_back_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto take_back_c = [](auto&& xs) { - return hana::take_back(forwarded(xs), hana::size_c<n>); - }; -#else - template <std::size_t n> - struct take_back_c_t; - - template <std::size_t n> - constexpr take_back_c_t<n> take_back_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TAKE_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/take_front.hpp b/contrib/restricted/boost/boost/hana/fwd/take_front.hpp deleted file mode 100644 index 9ce3b9c030..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/take_front.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Forward declares `boost::hana::take_front` and `boost::hana::take_front_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TAKE_FRONT_HPP -#define BOOST_HANA_FWD_TAKE_FRONT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Returns the first `n` elements of a sequence, or the whole sequence - //! if the sequence has less than `n` elements. - //! @ingroup group-Sequence - //! - //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_front(xs, n)` - //! is a new sequence containing the first `n` elements of `xs`, in the - //! same order. If `length(xs) <= n`, the whole sequence is returned and - //! no error is triggered. - //! - //! - //! @param xs - //! The sequence to take the elements from. - //! - //! @param n - //! A non-negative `IntegralConstant` representing the number of elements - //! to keep in the resulting sequence. - //! - //! - //! Example - //! ------- - //! @include example/take_front.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto take_front = [](auto&& xs, auto const& n) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct take_front_impl : take_front_impl<S, when<true>> { }; - - struct take_front_t { - template <typename Xs, typename N> - constexpr auto operator()(Xs&& xs, N const& n) const; - }; - - constexpr take_front_t take_front{}; -#endif - - //! Equivalent to `take_front`; provided for convenience. - //! @ingroup group-Sequence - //! - //! - //! Example - //! ------- - //! @include example/take_front_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <std::size_t n> - constexpr auto take_front_c = [](auto&& xs) { - return hana::take_front(forwarded(xs), hana::size_c<n>); - }; -#else - template <std::size_t n> - struct take_front_c_t; - - template <std::size_t n> - constexpr take_front_c_t<n> take_front_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TAKE_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/take_while.hpp b/contrib/restricted/boost/boost/hana/fwd/take_while.hpp deleted file mode 100644 index 29f1ba24e0..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/take_while.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Forward declares `boost::hana::take_while`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TAKE_WHILE_HPP -#define BOOST_HANA_FWD_TAKE_WHILE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Take elements from a sequence while the `predicate` is satisfied. - //! @ingroup group-Sequence - //! - //! Specifically, `take_while` returns a new sequence containing the - //! longest prefix of `xs` in which all the elements satisfy the given - //! predicate. - //! - //! - //! @param xs - //! The sequence to take elements from. - //! - //! @param predicate - //! A function called as `predicate(x)`, where `x` is an element of the - //! sequence, and returning a `Logical` representing whether `x` should be - //! included in the resulting sequence. In the current version of the - //! library, `predicate` has to return a `Constant Logical`. - //! - //! - //! Example - //! ------- - //! @include example/take_while.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto take_while = [](auto&& xs, auto&& predicate) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct take_while_impl : take_while_impl<S, when<true>> { }; - - struct take_while_t { - template <typename Xs, typename Pred> - constexpr auto operator()(Xs&& xs, Pred&& pred) const; - }; - - constexpr take_while_t take_while{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TAKE_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/tap.hpp b/contrib/restricted/boost/boost/hana/fwd/tap.hpp deleted file mode 100644 index 846c1d00e6..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/tap.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Forward declares `boost::hana::tap`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TAP_HPP -#define BOOST_HANA_FWD_TAP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Tap inside a monadic chain. - //! @ingroup group-Monad - //! - //! Given a function `f`, `tap<M>` returns a new function which performs - //! `f` on its argument and then returns the argument lifted in the `M` - //! `Monad`. Combined with the property that `chain(m, lift<M>) == m`, - //! this provides a way of executing an action inside a monadic chain - //! without influencing its overall result. This is useful to e.g. insert - //! debug statements or perform actions that are not tied to the chain but - //! that need to be executed inside of it. - //! - //! @note - //! Since C++ is not a pure language, it is possible to perform side - //! effects inside the `f` function. Actually, side effects are the - //! only reason why one might want to use `tap`. However, one should - //! not rely on the side effects being done in any specific order. - //! - //! - //! @tparam M - //! The tag (a `Monad`) of the monads in the tapped monadic chain. - //! - //! @param f - //! A function to be executed inside a monadic chain. It will be called - //! as `f(x)`, where `x` is a value inside the previous monad in the - //! chain. The result of `f` is always discarded. - //! - //! - //! Example - //! ------- - //! @include example/tap.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto tap = [](auto&& f) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct tap_impl : tap_impl<M, when<true>> { }; - - template <typename M> - struct tap_t; - - template <typename M> - constexpr tap_t<M> tap{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TAP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/then.hpp b/contrib/restricted/boost/boost/hana/fwd/then.hpp deleted file mode 100644 index b4adf3d4fe..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/then.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*! -@file -Forward declares `boost::hana::then`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_THEN_HPP -#define BOOST_HANA_FWD_THEN_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Sequentially compose two monadic actions, discarding any value - //! produced by the first but not its effects. - //! @ingroup group-Monad - //! - //! - //! @param before - //! The first `Monad` in the monadic composition chain. The result of - //! this monad is ignored, but its effects are combined with that of the - //! second monad. - //! - //! @param xs - //! The second `Monad` in the monadic composition chain. - //! - //! - //! Example - //! ------- - //! @include example/then.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto then = [](auto&& before, auto&& xs) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct then_impl : then_impl<M, when<true>> { }; - - struct then_t { - template <typename Before, typename Xs> - constexpr decltype(auto) operator()(Before&& before, Xs&& xs) const; - }; - - constexpr then_t then{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_THEN_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/transform.hpp b/contrib/restricted/boost/boost/hana/fwd/transform.hpp deleted file mode 100644 index af645f3d23..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/transform.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Forward declares `boost::hana::transform`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TRANSFORM_HPP -#define BOOST_HANA_FWD_TRANSFORM_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Map a function over a `Functor`. - //! @ingroup group-Functor - //! - //! - //! Signature - //! --------- - //! Given `F` a Functor, the signature is - //! \f$ - //! \mathtt{transform} : F(T) \times (T \to U) \to F(U) - //! \f$ - //! - //! @param xs - //! The structure to map `f` over. - //! - //! @param f - //! A function called as `f(x)` on element(s) `x` of the structure, - //! and returning a new value to replace `x` in the structure. - //! - //! - //! Example - //! ------- - //! @include example/transform.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto transform = [](auto&& xs, auto&& f) { - return tag-dispatched; - }; -#else - template <typename Xs, typename = void> - struct transform_impl : transform_impl<Xs, when<true>> { }; - - struct transform_t { - template <typename Xs, typename F> - constexpr auto operator()(Xs&& xs, F&& f) const; - }; - - constexpr transform_t transform{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TRANSFORM_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/tuple.hpp b/contrib/restricted/boost/boost/hana/fwd/tuple.hpp deleted file mode 100644 index f51ab9ac22..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/tuple.hpp +++ /dev/null @@ -1,224 +0,0 @@ -/*! -@file -Forward declares `boost::hana::tuple`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TUPLE_HPP -#define BOOST_HANA_FWD_TUPLE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/integral_constant.hpp> -#include <boost/hana/fwd/type.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @ingroup group-datatypes - //! General purpose index-based heterogeneous sequence with a fixed length. - //! - //! The tuple is the bread and butter for static metaprogramming. - //! Conceptually, it is like a `std::tuple`; it is a container able - //! of holding objects of different types and whose size is fixed at - //! compile-time. However, Hana's tuple provides much more functionality - //! than its `std` counterpart, and it is also much more efficient than - //! all standard library implementations tested so far. - //! - //! Tuples are index-based sequences. If you need an associative - //! sequence with a key-based access, then you should consider - //! `hana::map` or `hana::set` instead. - //! - //! - //! Modeled concepts - //! ---------------- - //! `Sequence`, and all the concepts it refines - //! - //! - //! Provided operators - //! ------------------ - //! For convenience, the following operators are provided: - //! @code - //! xs == ys -> equal(xs, ys) - //! xs != ys -> not_equal(xs, ys) - //! - //! xs < ys -> less(xs, ys) - //! xs <= ys -> less_equal(xs, ys) - //! xs > ys -> greater(xs, ys) - //! xs >= ys -> greater_equal(xs, ys) - //! - //! xs | f -> chain(xs, f) - //! - //! xs[n] -> at(xs, n) - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/tuple/tuple.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename ...Xn> - struct tuple { - //! Default constructs the `tuple`. Only exists when all the elements - //! of the tuple are default constructible. - constexpr tuple(); - - //! Initialize each element of the tuple with the corresponding element - //! from `xn...`. Only exists when all the elements of the tuple are - //! copy-constructible. - //! - //! @note - //! Unlike the corresponding constructor for `std::tuple`, this - //! constructor is not explicit. This allows returning a tuple - //! from a function with the brace-initialization syntax. - constexpr tuple(Xn const& ...xn); - - //! Initialize each element of the tuple by perfect-forwarding the - //! corresponding element in `yn...`. Only exists when all the - //! elements of the created tuple are constructible from the - //! corresponding perfect-forwarded value. - //! - //! @note - //! Unlike the corresponding constructor for `std::tuple`, this - //! constructor is not explicit. This allows returning a tuple - //! from a function with the brace-initialization syntax. - template <typename ...Yn> - constexpr tuple(Yn&& ...yn); - - //! Copy-initialize a tuple from another tuple. Only exists when all - //! the elements of the constructed tuple are copy-constructible from - //! the corresponding element in the source tuple. - template <typename ...Yn> - constexpr tuple(tuple<Yn...> const& other); - - //! Move-initialize a tuple from another tuple. Only exists when all - //! the elements of the constructed tuple are move-constructible from - //! the corresponding element in the source tuple. - template <typename ...Yn> - constexpr tuple(tuple<Yn...>&& other); - - //! Assign a tuple to another tuple. Only exists when all the elements - //! of the destination tuple are assignable from the corresponding - //! element in the source tuple. - template <typename ...Yn> - constexpr tuple& operator=(tuple<Yn...> const& other); - - //! Move-assign a tuple to another tuple. Only exists when all the - //! elements of the destination tuple are move-assignable from the - //! corresponding element in the source tuple. - template <typename ...Yn> - constexpr tuple& operator=(tuple<Yn...>&& other); - - //! Equivalent to `hana::chain`. - template <typename ...T, typename F> - friend constexpr auto operator|(tuple<T...>, F); - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - - //! Equivalent to `hana::less` - template <typename X, typename Y> - friend constexpr auto operator<(X&& x, Y&& y); - - //! Equivalent to `hana::greater` - template <typename X, typename Y> - friend constexpr auto operator>(X&& x, Y&& y); - - //! Equivalent to `hana::less_equal` - template <typename X, typename Y> - friend constexpr auto operator<=(X&& x, Y&& y); - - //! Equivalent to `hana::greater_equal` - template <typename X, typename Y> - friend constexpr auto operator>=(X&& x, Y&& y); - - //! Equivalent to `hana::at` - template <typename N> - constexpr decltype(auto) operator[](N&& n); - }; -#else - template <typename ...Xn> - struct tuple; -#endif - - //! Tag representing `hana::tuple`s. - //! @related tuple - struct tuple_tag { }; - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Function object for creating a `tuple`. - //! @relates hana::tuple - //! - //! Given zero or more objects `xs...`, `make<tuple_tag>` returns a new tuple - //! containing those objects. The elements are held by value inside the - //! resulting tuple, and they are hence copied or moved in. This is - //! analogous to `std::make_tuple` for creating Hana tuples. - //! - //! - //! Example - //! ------- - //! @include example/tuple/make.cpp - template <> - constexpr auto make<tuple_tag> = [](auto&& ...xs) { - return tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; - }; -#endif - - //! Alias to `make<tuple_tag>`; provided for convenience. - //! @relates hana::tuple - constexpr auto make_tuple = make<tuple_tag>; - - //! Equivalent to `to<tuple_tag>`; provided for convenience. - //! @relates hana::tuple - constexpr auto to_tuple = to<tuple_tag>; - - //! Create a tuple specialized for holding `hana::type`s. - //! @relates hana::tuple - //! - //! This is functionally equivalent to `make<tuple_tag>(type_c<T>...)`, except - //! that using `tuple_t` allows the library to perform some compile-time - //! optimizations. Also note that the type of the objects returned by - //! `tuple_t` and an equivalent call to `make<tuple_tag>` may differ. - //! - //! - //! Example - //! ------- - //! @include example/tuple/tuple_t.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename ...T> - constexpr implementation_defined tuple_t{}; -#else - template <typename ...T> - constexpr hana::tuple<hana::type<T>...> tuple_t{}; -#endif - - //! Create a tuple specialized for holding `hana::integral_constant`s. - //! @relates hana::tuple - //! - //! This is functionally equivalent to `make<tuple_tag>(integral_c<T, v>...)`, - //! except that using `tuple_c` allows the library to perform some - //! compile-time optimizations. Also note that the type of the objects - //! returned by `tuple_c` and an equivalent call to `make<tuple_tag>` may differ. - //! - //! - //! Example - //! ------- - //! @include example/tuple/tuple_c.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T, T ...v> - constexpr implementation_defined tuple_c{}; -#else - template <typename T, T ...v> - constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/type.hpp b/contrib/restricted/boost/boost/hana/fwd/type.hpp deleted file mode 100644 index c3c220db78..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/type.hpp +++ /dev/null @@ -1,535 +0,0 @@ -/*! -@file -Forward declares `boost::hana::type` and related utilities. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_TYPE_HPP -#define BOOST_HANA_FWD_TYPE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/fwd/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Base class of `hana::type`; used for pattern-matching. - //! @relates hana::type - //! - //! Example - //! ------- - //! @include example/type/basic_type.cpp - template <typename T> - struct basic_type; - - //! @ingroup group-datatypes - //! C++ type in value-level representation. - //! - //! A `type` is a special kind of object representing a C++ type like - //! `int`, `void`, `std::vector<float>` or anything else you can imagine. - //! - //! This page explains how `type`s work at a low level. To gain - //! intuition about type-level metaprogramming in Hana, you should - //! read the [tutorial section](@ref tutorial-type) on type-level - //! computations. - //! - //! - //! @note - //! For subtle reasons, the actual representation of `hana::type` is - //! implementation-defined. In particular, `hana::type` may be a dependent - //! type, so one should not attempt to do pattern matching on it. However, - //! one can assume that `hana::type` _inherits_ from `hana::basic_type`, - //! which can be useful when declaring overloaded functions: - //! @code - //! template <typename T> - //! void f(hana::basic_type<T>) { - //! // do something with T - //! } - //! @endcode - //! The full story is that [ADL][] causes template arguments to be - //! instantiated. Hence, if `hana::type` were defined naively, expressions - //! like `hana::type<T>{} == hana::type<U>{}` would cause both `T` and `U` - //! to be instantiated. This is usually not a problem, except when `T` or - //! `U` should not be instantiated. To avoid these instantiations, - //! `hana::type` is implemented using some cleverness, and that is - //! why the representation is implementation-defined. When that - //! behavior is not required, `hana::basic_type` can be used instead. - //! - //! - //! @anchor type_lvalues_and_rvalues - //! Lvalues and rvalues - //! ------------------- - //! When storing `type`s in heterogeneous containers, some algorithms - //! will return references to those objects. Since we are primarily - //! interested in accessing their nested `::%type`, receiving a reference - //! is undesirable; we would end up trying to fetch the nested `::%type` - //! inside a reference type, which is a compilation error: - //! @code - //! auto ts = make_tuple(type_c<int>, type_c<char>); - //! using T = decltype(ts[0_c])::type; // error: 'ts[0_c]' is a reference! - //! @endcode - //! - //! For this reason, `type`s provide an overload of the unary `+` - //! operator that can be used to turn a lvalue into a rvalue. So when - //! using a result which might be a reference to a `type` object, one - //! can use `+` to make sure a rvalue is obtained before fetching its - //! nested `::%type`: - //! @code - //! auto ts = make_tuple(type_c<int>, type_c<char>); - //! using T = decltype(+ts[0_c])::type; // ok: '+ts[0_c]' is an rvalue - //! @endcode - //! - //! - //! Modeled concepts - //! ---------------- - //! 1. `Comparable`\n - //! Two types are equal if and only if they represent the same C++ type. - //! Hence, equality is equivalent to the `std::is_same` type trait. - //! @include example/type/comparable.cpp - //! - //! 2. `Hashable`\n - //! The hash of a type is just that type itself. In other words, `hash` - //! is the identity function on `hana::type`s. - //! @include example/type/hashable.cpp - //! - //! [ADL]: http://en.cppreference.com/w/cpp/language/adl -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T> - struct type { - //! Returns rvalue of self. - //! See @ref type_lvalues_and_rvalues "description". - constexpr auto operator+() const; - - //! Equivalent to `hana::equal` - template <typename X, typename Y> - friend constexpr auto operator==(X&& x, Y&& y); - - //! Equivalent to `hana::not_equal` - template <typename X, typename Y> - friend constexpr auto operator!=(X&& x, Y&& y); - }; -#else - template <typename T> - struct type_impl; - - template <typename T> - using type = typename type_impl<T>::_; -#endif - - //! Tag representing `hana::type`. - //! @relates hana::type - struct type_tag { }; - - //! Creates an object representing the C++ type `T`. - //! @relates hana::type - template <typename T> - constexpr type<T> type_c{}; - - //! `decltype` keyword, lifted to Hana. - //! @relates hana::type - //! - //! @deprecated - //! The semantics of `decltype_` can be confusing, and `hana::typeid_` - //! should be preferred instead. `decltype_` may be removed in the next - //! major version of the library. - //! - //! `decltype_` is somewhat equivalent to `decltype` in that it returns - //! the type of an object, except it returns it as a `hana::type` which - //! is a first-class citizen of Hana instead of a raw C++ type. - //! Specifically, given an object `x`, `decltype_` satisfies - //! @code - //! decltype_(x) == type_c<decltype(x) with references stripped> - //! @endcode - //! - //! As you can see, `decltype_` will strip any reference from the - //! object's actual type. The reason for doing so is explained below. - //! However, any `cv`-qualifiers will be retained. Also, when given a - //! `hana::type`, `decltype_` is just the identity function. Hence, - //! for any C++ type `T`, - //! @code - //! decltype_(type_c<T>) == type_c<T> - //! @endcode - //! - //! In conjunction with the way `metafunction` & al. are specified, this - //! behavior makes it easier to interact with both types and values at - //! the same time. However, it does make it impossible to create a `type` - //! containing another `type` with `decltype_`. In other words, it is - //! not possible to create a `type_c<decltype(type_c<T>)>` with this - //! utility, because `decltype_(type_c<T>)` would be just `type_c<T>` - //! instead of `type_c<decltype(type_c<T>)>`. This use case is assumed - //! to be rare and a hand-coded function can be used if this is needed. - //! - //! - //! ### Rationale for stripping the references - //! The rules for template argument deduction are such that a perfect - //! solution that always matches `decltype` is impossible. Hence, we - //! have to settle on a solution that's good and and consistent enough - //! for our needs. One case where matching `decltype`'s behavior is - //! impossible is when the argument is a plain, unparenthesized variable - //! or function parameter. In that case, `decltype_`'s argument will be - //! deduced as a reference to that variable, but `decltype` would have - //! given us the actual type of that variable, without references. Also, - //! given the current definition of `metafunction` & al., it would be - //! mostly useless if `decltype_` could return a reference, because it - //! is unlikely that `F` expects a reference in its simplest use case: - //! @code - //! int i = 0; - //! auto result = metafunction<F>(i); - //! @endcode - //! - //! Hence, always discarding references seems to be the least painful - //! solution. - //! - //! - //! Example - //! ------- - //! @include example/type/decltype.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto decltype_ = see documentation; -#else - struct decltype_t { - template <typename T> - constexpr auto operator()(T&&) const; - }; - - constexpr decltype_t decltype_{}; -#endif - - //! Returns a `hana::type` representing the type of a given object. - //! @relates hana::type - //! - //! `hana::typeid_` is somewhat similar to `typeid` in that it returns - //! something that represents the type of an object. However, what - //! `typeid` returns represent the _runtime_ type of the object, while - //! `hana::typeid_` returns the _static_ type of the object. Specifically, - //! given an object `x`, `typeid_` satisfies - //! @code - //! typeid_(x) == type_c<decltype(x) with ref and cv-qualifiers stripped> - //! @endcode - //! - //! As you can see, `typeid_` strips any reference and cv-qualifier from - //! the object's actual type. The reason for doing so is that it faithfully - //! models how the language's `typeid` behaves with respect to reference - //! and cv-qualifiers, and it also turns out to be the desirable behavior - //! most of the time. Also, when given a `hana::type`, `typeid_` is just - //! the identity function. Hence, for any C++ type `T`, - //! @code - //! typeid_(type_c<T>) == type_c<T> - //! @endcode - //! - //! In conjunction with the way `metafunction` & al. are specified, this - //! behavior makes it easier to interact with both types and values at - //! the same time. However, it does make it impossible to create a `type` - //! containing another `type` using `typeid_`. This use case is assumed - //! to be rare and a hand-coded function can be used if this is needed. - //! - //! - //! Example - //! ------- - //! @include example/type/typeid.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto typeid_ = see documentation; -#else - struct typeid_t { - template <typename T> - constexpr auto operator()(T&&) const; - }; - - constexpr typeid_t typeid_{}; -#endif - -#ifdef BOOST_HANA_DOXYGEN_INVOKED - //! Equivalent to `decltype_`, provided for convenience. - //! @relates hana::type - //! - //! - //! Example - //! ------- - //! @include example/type/make.cpp - template <> - constexpr auto make<type_tag> = hana::decltype_; -#endif - - //! Equivalent to `make<type_tag>`, provided for convenience. - //! @relates hana::type - //! - //! - //! Example - //! ------- - //! @include example/type/make.cpp - constexpr auto make_type = hana::make<type_tag>; - - //! `sizeof` keyword, lifted to Hana. - //! @relates hana::type - //! - //! `sizeof_` is somewhat equivalent to `sizeof` in that it returns the - //! size of an expression or type, but it takes an arbitrary expression - //! or a `hana::type` and returns its size as an `integral_constant`. - //! Specifically, given an expression `expr`, `sizeof_` satisfies - //! @code - //! sizeof_(expr) == size_t<sizeof(decltype(expr) with references stripped)> - //! @endcode - //! - //! However, given a `type`, `sizeof_` will simply fetch the size - //! of the C++ type represented by that object. In other words, - //! @code - //! sizeof_(type_c<T>) == size_t<sizeof(T)> - //! @endcode - //! - //! The behavior of `sizeof_` is consistent with that of `decltype_`. - //! In particular, see `decltype_`'s documentation to understand why - //! references are always stripped by `sizeof_`. - //! - //! - //! Example - //! ------- - //! @include example/type/sizeof.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto sizeof_ = [](auto&& x) { - using T = typename decltype(hana::decltype_(x))::type; - return hana::size_c<sizeof(T)>; - }; -#else - struct sizeof_t { - template <typename T> - constexpr auto operator()(T&&) const; - }; - - constexpr sizeof_t sizeof_{}; -#endif - - //! `alignof` keyword, lifted to Hana. - //! @relates hana::type - //! - //! `alignof_` is somewhat equivalent to `alignof` in that it returns the - //! alignment required by any instance of a type, but it takes a `type` - //! and returns its alignment as an `integral_constant`. Like `sizeof` - //! which works for expressions and type-ids, `alignof_` can also be - //! called on an arbitrary expression. Specifically, given an expression - //! `expr` and a C++ type `T`, `alignof_` satisfies - //! @code - //! alignof_(expr) == size_t<alignof(decltype(expr) with references stripped)> - //! alignof_(type_c<T>) == size_t<alignof(T)> - //! @endcode - //! - //! The behavior of `alignof_` is consistent with that of `decltype_`. - //! In particular, see `decltype_`'s documentation to understand why - //! references are always stripped by `alignof_`. - //! - //! - //! Example - //! ------- - //! @include example/type/alignof.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto alignof_ = [](auto&& x) { - using T = typename decltype(hana::decltype_(x))::type; - return hana::size_c<alignof(T)>; - }; -#else - struct alignof_t { - template <typename T> - constexpr auto operator()(T&&) const; - }; - - constexpr alignof_t alignof_{}; -#endif - - //! Checks whether a SFINAE-friendly expression is valid. - //! @relates hana::type - //! - //! Given a SFINAE-friendly function, `is_valid` returns whether the - //! function call is valid with the given arguments. Specifically, given - //! a function `f` and arguments `args...`, - //! @code - //! is_valid(f, args...) == whether f(args...) is valid - //! @endcode - //! - //! The result is returned as a compile-time `Logical`. Furthermore, - //! `is_valid` can be used in curried form as follows: - //! @code - //! is_valid(f)(args...) - //! @endcode - //! - //! This syntax makes it easy to create functions that check the validity - //! of a generic expression on any given argument(s). - //! - //! @warning - //! To check whether calling a nullary function `f` is valid, one should - //! use the `is_valid(f)()` syntax. Indeed, `is_valid(f /* no args */)` - //! will be interpreted as the currying of `is_valid` to `f` rather than - //! the application of `is_valid` to `f` and no arguments. - //! - //! - //! Example - //! ------- - //! @include example/type/is_valid.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto is_valid = [](auto&& f) { - return [](auto&& ...args) { - return whether f(args...) is a valid expression; - }; - }; -#else - struct is_valid_t { - template <typename F> - constexpr auto operator()(F&&) const; - - template <typename F, typename ...Args> - constexpr auto operator()(F&&, Args&&...) const; - }; - - constexpr is_valid_t is_valid{}; -#endif - - //! Lift a template to a Metafunction. - //! @ingroup group-Metafunction - //! - //! Given a template class or template alias `f`, `template_<f>` is a - //! `Metafunction` satisfying - //! @code - //! template_<f>(type_c<x>...) == type_c<f<x...>> - //! decltype(template_<f>)::apply<x...>::type == f<x...> - //! @endcode - //! - //! @note - //! `template_` can't be SFINAE-friendly right now because of - //! [Core issue 1430][1]. - //! - //! - //! Example - //! ------- - //! @include example/type/template.cpp - //! - //! [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430 -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <template <typename ...> class F> - constexpr auto template_ = [](basic_type<T>...) { - return hana::type_c<F<T...>>; - }; -#else - template <template <typename ...> class F> - struct template_t; - - template <template <typename ...> class F> - constexpr template_t<F> template_{}; -#endif - - //! Lift a MPL-style metafunction to a Metafunction. - //! @ingroup group-Metafunction - //! - //! Given a MPL-style metafunction, `metafunction<f>` is a `Metafunction` - //! satisfying - //! @code - //! metafunction<f>(type_c<x>...) == type_c<f<x...>::type> - //! decltype(metafunction<f>)::apply<x...>::type == f<x...>::type - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/type/metafunction.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <template <typename ...> class F> - constexpr auto metafunction = [](basic_type<T>...) { - return hana::type_c<typename F<T...>::type>; - }; -#else - template <template <typename ...> class f> - struct metafunction_t; - - template <template <typename ...> class f> - constexpr metafunction_t<f> metafunction{}; -#endif - - //! Lift a MPL-style metafunction class to a Metafunction. - //! @ingroup group-Metafunction - //! - //! Given a MPL-style metafunction class, `metafunction_class<f>` is a - //! `Metafunction` satisfying - //! @code - //! metafunction_class<f>(type_c<x>...) == type_c<f::apply<x...>::type> - //! decltype(metafunction_class<f>)::apply<x...>::type == f::apply<x...>::type - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/type/metafunction_class.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename F> - constexpr auto metafunction_class = [](basic_type<T>...) { - return hana::type_c<typename F::template apply<T...>::type>; - }; -#else - template <typename F> - struct metafunction_class_t - : metafunction_t<F::template apply> - { }; - - template <typename F> - constexpr metafunction_class_t<F> metafunction_class{}; -#endif - - //! Turn a `Metafunction` into a function taking `type`s and returning a - //! default-constructed object. - //! @ingroup group-Metafunction - //! - //! Given a `Metafunction` `f`, `integral` returns a new `Metafunction` - //! that default-constructs an object of the type returned by `f`. More - //! specifically, the following holds: - //! @code - //! integral(f)(t...) == decltype(f(t...))::type{} - //! @endcode - //! - //! The principal use case for `integral` is to transform `Metafunction`s - //! returning a type that inherits from a meaningful base like - //! `std::integral_constant` into functions returning e.g. a - //! `hana::integral_constant`. - //! - //! @note - //! - This is not a `Metafunction` because it does not return a `type`. - //! As such, it would not make sense to make `decltype(integral(f))` - //! a MPL metafunction class like the usual `Metafunction`s are. - //! - //! - When using `integral` with metafunctions returning - //! `std::integral_constant`s, don't forget to include the - //! boost/hana/ext/std/integral_constant.hpp header to ensure - //! Hana can interoperate with the result. - //! - //! - //! Example - //! ------- - //! @include example/type/integral.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto integral = [](auto f) { - return [](basic_type<T>...) { - return decltype(f)::apply<T...>::type{}; - }; - }; -#else - template <typename F> - struct integral_t; - - struct make_integral_t { - template <typename F> - constexpr integral_t<F> operator()(F const&) const - { return {}; } - }; - - constexpr make_integral_t integral{}; -#endif - - //! Alias to `integral(metafunction<F>)`, provided for convenience. - //! @ingroup group-Metafunction - //! - //! - //! Example - //! ------- - //! @include example/type/trait.cpp - template <template <typename ...> class F> - constexpr auto trait = hana::integral(hana::metafunction<F>); -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_TYPE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/unfold_left.hpp b/contrib/restricted/boost/boost/hana/fwd/unfold_left.hpp deleted file mode 100644 index d753222630..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/unfold_left.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Forward declares `boost::hana::unfold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_UNFOLD_LEFT_HPP -#define BOOST_HANA_FWD_UNFOLD_LEFT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Dual operation to `fold_left` for sequences. - //! @ingroup group-Sequence - //! - //! While `fold_left` reduces a structure to a summary value from the left, - //! `unfold_left` builds a sequence from a seed value and a function, - //! starting from the left. - //! - //! - //! Signature - //! --------- - //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an - //! arbitrary Product `P` and a function \f$ f : I \to P(I, T) \f$, - //! `unfold_left<S>` has the following signature: - //! \f[ - //! \mathtt{unfold\_left}_S : I \times (I \to P(I, T)) \to S(T) - //! \f] - //! - //! @tparam S - //! The tag of the sequence to build up. - //! - //! @param state - //! An initial value to build the sequence from. - //! - //! @param f - //! A function called as `f(state)`, where `state` is an initial value, - //! and returning - //! 1. `nothing` if it is done producing the sequence. - //! 2. otherwise, `just(make<P>(state, x))`, where `state` is the new - //! initial value used in the next call to `f`, `x` is an element to - //! be appended to the resulting sequence, and `P` is an arbitrary - //! `Product`. - //! - //! - //! Fun fact - //! --------- - //! In some cases, `unfold_left` can undo a `fold_left` operation: - //! @code - //! unfold_left<S>(fold_left(xs, state, f), g) == xs - //! @endcode - //! - //! if the following holds - //! @code - //! g(f(x, y)) == just(make_pair(x, y)) - //! g(state) == nothing - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/unfold_left.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename S> - constexpr auto unfold_left = [](auto&& state, auto&& f) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct unfold_left_impl : unfold_left_impl<S, when<true>> { }; - - template <typename S> - struct unfold_left_t; - - template <typename S> - constexpr unfold_left_t<S> unfold_left{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_UNFOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/unfold_right.hpp b/contrib/restricted/boost/boost/hana/fwd/unfold_right.hpp deleted file mode 100644 index 53ee56fc48..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/unfold_right.hpp +++ /dev/null @@ -1,85 +0,0 @@ -/*! -@file -Forward declares `boost::hana::unfold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_UNFOLD_RIGHT_HPP -#define BOOST_HANA_FWD_UNFOLD_RIGHT_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Dual operation to `fold_right` for sequences. - //! @ingroup group-Sequence - //! - //! While `fold_right` reduces a structure to a summary value from the - //! right, `unfold_right` builds a sequence from a seed value and a - //! function, starting from the right. - //! - //! - //! Signature - //! --------- - //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an - //! arbitrary Product `P` and a function \f$ f : I \to P(T, I) \f$, - //! `unfold_right<S>` has the following signature: - //! \f[ - //! \mathtt{unfold\_right}_S : I \times (I \to P(T, I)) \to S(T) - //! \f] - //! - //! @tparam S - //! The tag of the sequence to build up. - //! - //! @param state - //! An initial value to build the sequence from. - //! - //! @param f - //! A function called as `f(state)`, where `state` is an initial value, - //! and returning - //! 1. `nothing` if it is done producing the sequence. - //! 2. otherwise, `just(make<P>(x, state))`, where `state` is the new - //! initial value used in the next call to `f`, `x` is an element to - //! be prepended to the resulting sequence, and `P` is an arbitrary - //! `Product`. - //! - //! - //! Fun fact - //! --------- - //! In some cases, `unfold_right` can undo a `fold_right` operation: - //! @code - //! unfold_right<S>(fold_right(xs, state, f), g) == xs - //! @endcode - //! - //! if the following holds - //! @code - //! g(f(x, y)) == just(make_pair(x, y)) - //! g(state) == nothing - //! @endcode - //! - //! - //! Example - //! ------- - //! @include example/unfold_right.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename S> - constexpr auto unfold_right = [](auto&& state, auto&& f) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct unfold_right_impl : unfold_right_impl<S, when<true>> { }; - - template <typename S> - struct unfold_right_t; - - template <typename S> - constexpr unfold_right_t<S> unfold_right{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_UNFOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/union.hpp b/contrib/restricted/boost/boost/hana/fwd/union.hpp deleted file mode 100644 index 5775151888..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/union.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*! -@file -Forward declares `boost::hana::union_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_UNION_HPP -#define BOOST_HANA_FWD_UNION_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - // Note: This function is documented per datatype/concept only. - //! @cond - template <typename T, typename = void> - struct union_impl : union_impl<T, when<true>> { }; - //! @endcond - - struct union_t { - template <typename Xs, typename Ys> - constexpr auto operator()(Xs&&, Ys&&) const; - }; - - constexpr union_t union_{}; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_UNION_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/unique.hpp b/contrib/restricted/boost/boost/hana/fwd/unique.hpp deleted file mode 100644 index 5eab73eb3b..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/unique.hpp +++ /dev/null @@ -1,91 +0,0 @@ -/*! -@file -Forward declares `boost::hana::unique`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_UNIQUE_HPP -#define BOOST_HANA_FWD_UNIQUE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> -#include <boost/hana/detail/nested_by_fwd.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Removes all consecutive duplicate elements from a Sequence. - //! @ingroup group-Sequence - //! - //! Given a `Sequence` and an optional binary predicate, `unique` returns - //! a new sequence containing only the first element of every subrange - //! of the original sequence whose elements are all equal. In other words, - //! it turns a sequence of the form `[a, a, b, c, c, c, d, d, d, a]` into - //! a sequence `[a, b, c, d, a]`. The equality of two elements is - //! determined by the provided `predicate`, or by `equal` if no - //! `predicate` is provided. - //! - //! - //! Signature - //! --------- - //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a binary predicate - //! \f$ T \times T \to Bool \f$, `unique` has the following signature: - //! \f[ - //! \mathtt{unique} : S(T) \times (T \times T \to Bool) \to S(T) - //! \f] - //! - //! @param xs - //! The sequence from which to remove consecutive duplicates. - //! - //! @param predicate - //! A function called as `predicate(x, y)`, where `x` and `y` are adjacent - //! elements of the sequence, and returning a `Logical` representing - //! whether `x` and `y` should be considered equal. `predicate` should - //! define an [equivalence relation][1] over the elements of the sequence. - //! In the current implementation of the library, `predicate` has to - //! return a compile-time `Logical`. This parameter is optional; it - //! defaults to `equal` if it is not provided, which then requires the - //! elements of the sequence to be compile-time `Comparable`. - //! - //! - //! Syntactic sugar (`unique.by`) - //! ----------------------------- - //! `unique` can be called in an alternate way, which provides a nice - //! syntax, especially in conjunction with the `comparing` combinator: - //! @code - //! unique.by(predicate, xs) == unique(xs, predicate) - //! unique.by(predicate) == unique(-, predicate) - //! @endcode - //! - //! where `unique(-, predicate)` denotes the partial application of - //! `unique` to `predicate`. - //! - //! - //! Example - //! ------- - //! @include example/unique.cpp - //! - //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition -#if defined(BOOST_HANA_DOXYGEN_INVOKED) - constexpr auto unique = [](auto&& xs[, auto&& predicate]) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct unique_impl : unique_impl<S, when<true>> { }; - - struct unique_t : detail::nested_by<unique_t> { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const; - - template <typename Xs, typename Predicate> - constexpr auto operator()(Xs&& xs, Predicate&& predicate) const; - }; - - constexpr unique_t unique{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_UNIQUE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/unpack.hpp b/contrib/restricted/boost/boost/hana/fwd/unpack.hpp deleted file mode 100644 index f66c29ae8b..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/unpack.hpp +++ /dev/null @@ -1,95 +0,0 @@ -/*! -@file -Forward declares `boost::hana::unpack`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_UNPACK_HPP -#define BOOST_HANA_FWD_UNPACK_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Invoke a function with the elements of a Foldable as arguments. - //! @ingroup group-Foldable - //! - //! Given a function and a foldable structure whose length can be known at - //! compile-time, `unpack` invokes the function with the contents of that - //! structure. In other words, `unpack(xs, f)` is equivalent to `f(x...)`, - //! where `x...` are the elements of the structure. The length of the - //! structure must be known at compile-time, because the version of `f`'s - //! `operator()` that will be compiled depends on the number of arguments - //! it is called with, which has to be known at compile-time. - //! - //! To create a function that accepts a foldable instead of variadic - //! arguments, see `fuse` instead. - //! - //! - //! @param xs - //! The structure to expand into the function. - //! - //! @param f - //! A function to be invoked as `f(x...)`, where `x...` are the elements - //! of the structure as-if they had been linearized with `to<tuple_tag>`. - //! - //! - //! Example - //! ------- - //! @include example/unpack.cpp - //! - //! - //! Rationale: `unpack`'s name and parameter order - //! ---------------------------------------------- - //! It has been suggested a couple of times that `unpack` be called - //! `apply` instead, and that the parameter order be reversed to match - //! that of the [proposed std::apply function][1]. However, the name - //! `apply` is already used to denote normal function application, an use - //! which is consistent with the Boost MPL library and with the rest of - //! the world, especially the functional programming community. - //! Furthermore, the author of this library considers the proposed - //! `std::apply` to have both an unfortunate name and an unfortunate - //! parameter order. Indeed, taking the function as the first argument - //! means that using `std::apply` with a lambda function looks like - //! @code - //! std::apply([](auto ...args) { - //! use(args...); - //! }, tuple); - //! @endcode - //! - //! which is undeniably ugly because of the trailing `, tuple)` part - //! on the last line. On the other hand, taking the function as a - //! second argument allows one to write - //! @code - //! hana::unpack(tuple, [](auto ...args) { - //! use(args...); - //! }); - //! @endcode - //! - //! which looks much nicer. Because of these observations, the author - //! of this library feels justified to use `unpack` instead of `apply`, - //! and to use a sane parameter order. - //! - //! [1]: http://en.cppreference.com/w/cpp/experimental/apply -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto unpack = [](auto&& xs, auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename T, typename = void> - struct unpack_impl : unpack_impl<T, when<true>> { }; - - struct unpack_t { - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; - }; - - constexpr unpack_t unpack{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_UNPACK_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/value.hpp b/contrib/restricted/boost/boost/hana/fwd/value.hpp deleted file mode 100644 index 7db9384f77..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/value.hpp +++ /dev/null @@ -1,100 +0,0 @@ -/*! -@file -Forward declares `boost::hana::value`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_VALUE_HPP -#define BOOST_HANA_FWD_VALUE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Return the compile-time value associated to a constant. - //! @ingroup group-Constant - //! - //! This function returns the value associated to a `Constant`. That - //! value is always a constant expression. The normal way of using - //! `value` on an object `c` is - //! @code - //! constexpr auto result = hana::value<decltype(c)>(); - //! @endcode - //! - //! However, for convenience, an overload of `value` is provided so that - //! it can be called as: - //! @code - //! constexpr auto result = hana::value(c); - //! @endcode - //! - //! This overload works by taking a `const&` to its argument, and then - //! forwarding to the first version of `value`. Since it does not use - //! its argument, the result can still be a constant expression, even - //! if the argument is not a constant expression. - //! - //! @note - //! `value<T>()` is tag-dispatched as `value_impl<C>::%apply<T>()`, where - //! `C` is the tag of `T`. - //! - //! @note - //! `hana::value` is an overloaded function, not a function object. - //! Hence, it can't be passed to higher-order algorithms. If you need - //! an equivalent function object, use `hana::value_of` instead. - //! - //! - //! Example - //! ------- - //! @include example/value.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename T> - constexpr auto value = []() -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename C, typename = void> - struct value_impl : value_impl<C, when<true>> { }; - - template <typename T> - constexpr decltype(auto) value(); - - template <typename T> - constexpr decltype(auto) value(T const&) - { return hana::value<T>(); } -#endif - - //! Equivalent to `value`, but can be passed to higher-order algorithms. - //! @ingroup group-Constant - //! - //! This function object is equivalent to `value`, except it can be passed - //! to higher order algorithms because it is a function object. `value` - //! can't be passed to higher-order algorithms because it is implemented - //! as an overloaded function. - //! - //! @note - //! This function is a simple alias to `value`, and hence it is not - //! tag-dispatched and can't be customized. - //! - //! - //! Example - //! ------- - //! @include example/value_of.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto value_of = [](auto const& c) -> decltype(auto) { - return hana::value(c); - }; -#else - struct value_of_t { - template <typename T> - constexpr decltype(auto) operator()(T const&) const - { return hana::value<T>(); } - }; - - constexpr value_of_t value_of{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_VALUE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/while.hpp b/contrib/restricted/boost/boost/hana/fwd/while.hpp deleted file mode 100644 index 14923797b5..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/while.hpp +++ /dev/null @@ -1,71 +0,0 @@ -/*! -@file -Forward declares `boost::hana::while_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_WHILE_HPP -#define BOOST_HANA_FWD_WHILE_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Apply a function to an initial state while some predicate is satisfied. - //! @ingroup group-Logical - //! - //! This method is a natural extension of the `while` language construct - //! to manipulate a state whose type may change from one iteration to - //! another. However, note that having a state whose type changes from - //! one iteration to the other is only possible as long as the predicate - //! returns a `Logical` whose truth value is known at compile-time. - //! - //! Specifically, `while_(pred, state, f)` is equivalent to - //! @code - //! f(...f(f(state))) - //! @endcode - //! where `f` is iterated as long as `pred(f(...))` is a true-valued - //! `Logical`. - //! - //! - //! @param pred - //! A predicate called on the state or on the result of applying `f` a - //! certain number of times to the state, and returning whether `f` - //! should be applied one more time. - //! - //! @param state - //! The initial state on which `f` is applied. - //! - //! @param f - //! A function that is iterated on the initial state. Note that the - //! return type of `f` may change from one iteration to the other, - //! but only while `pred` returns a compile-time `Logical`. In other - //! words, `decltype(f(stateN))` may differ from `decltype(f(stateN+1))`, - //! but only if `pred(f(stateN))` returns a compile-time `Logical`. - //! - //! - //! Example - //! ------- - //! @include example/while.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto while_ = [](auto&& pred, auto&& state, auto&& f) -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename L, typename = void> - struct while_impl : while_impl<L, when<true>> { }; - - struct while_t { - template <typename Pred, typename State, typename F> - constexpr decltype(auto) operator()(Pred&& pred, State&& state, F&& f) const; - }; - - constexpr while_t while_{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/zero.hpp b/contrib/restricted/boost/boost/hana/fwd/zero.hpp deleted file mode 100644 index 412614786d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/zero.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Forward declares `boost::hana::zero`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ZERO_HPP -#define BOOST_HANA_FWD_ZERO_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Identity of `plus`. - //! @ingroup group-Monoid - //! - //! @tparam M - //! The tag (a `Monoid`) of the returned identity. - //! - //! - //! Example - //! ------- - //! @include example/zero.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - template <typename M> - constexpr auto zero = []() -> decltype(auto) { - return tag-dispatched; - }; -#else - template <typename M, typename = void> - struct zero_impl : zero_impl<M, when<true>> { }; - - template <typename M> - struct zero_t; - - template <typename M> - constexpr zero_t<M> zero{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ZERO_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/zip.hpp b/contrib/restricted/boost/boost/hana/fwd/zip.hpp deleted file mode 100644 index 505decfcf0..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/zip.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Forward declares `boost::hana::zip`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ZIP_HPP -#define BOOST_HANA_FWD_ZIP_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Zip one sequence or more. - //! @ingroup group-Sequence - //! - //! Given `n` sequences `s1, ..., sn`, `zip` produces a sequence whose - //! `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` - //! denotes the `i`-th element of the `k`-th sequence. In other words, - //! `zip` produces a sequence of the form - //! @code - //! [ - //! make_tuple(s1[0], ..., sn[0]), - //! make_tuple(s1[1], ..., sn[1]), - //! ... - //! make_tuple(s1[M], ..., sn[M]) - //! ] - //! @endcode - //! where `M` is the length of the sequences, which are all assumed to - //! have the same length. Assuming the sequences to all have the same size - //! allows the library to perform some optimizations. To zip sequences - //! that may have different lengths, `zip_shortest` should be used - //! instead. Also note that it is an error to provide no sequence at all, - //! i.e. `zip` expects at least one sequence. - //! - //! - //! Example - //! ------- - //! @include example/zip.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto zip = [](auto&& x1, ..., auto&& xn) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct zip_impl : zip_impl<S, when<true>> { }; - - struct zip_t { - template <typename Xs, typename ...Ys> - constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; - }; - - constexpr zip_t zip{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ZIP_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/zip_shortest.hpp b/contrib/restricted/boost/boost/hana/fwd/zip_shortest.hpp deleted file mode 100644 index 5f0622789d..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/zip_shortest.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Forward declares `boost::hana::zip_shortest`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ZIP_SHORTEST_HPP -#define BOOST_HANA_FWD_ZIP_SHORTEST_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Zip one sequence or more. - //! @ingroup group-Sequence - //! - //! Given `n` sequences `s1, ..., sn`, `zip_shortest` produces a sequence - //! whose `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` - //! denotes the `i`-th element of the `k`-th sequence. In other words, - //! `zip_shortest` produces a sequence of the form - //! @code - //! [ - //! make_tuple(s1[0], ..., sn[0]), - //! make_tuple(s1[1], ..., sn[1]), - //! ... - //! make_tuple(s1[M], ..., sn[M]) - //! ] - //! @endcode - //! where `M` is the length of the shortest sequence. Hence, the returned - //! sequence stops when the shortest input sequence is exhausted. If you - //! know that all the sequences you are about to zip have the same length, - //! you should use `zip` instead, since it can be more optimized. Also - //! note that it is an error to provide no sequence at all, i.e. - //! `zip_shortest` expects at least one sequence. - //! - //! - //! Example - //! ------- - //! @include example/zip_shortest.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto zip_shortest = [](auto&& x1, ..., auto&& xn) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct zip_shortest_impl : zip_shortest_impl<S, when<true>> { }; - - struct zip_shortest_t { - template <typename Xs, typename ...Ys> - constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; - }; - - constexpr zip_shortest_t zip_shortest{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ZIP_SHORTEST_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/zip_shortest_with.hpp b/contrib/restricted/boost/boost/hana/fwd/zip_shortest_with.hpp deleted file mode 100644 index 47d5a43b61..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/zip_shortest_with.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Forward declares `boost::hana::zip_shortest_with`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP -#define BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Zip one sequence or more with a given function. - //! @ingroup group-Sequence - //! - //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, - //! `zip_shortest_with` produces a sequence whose `i`-th element is - //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of - //! the `k`-th sequence. In other words, `zip_shortest_with` produces a - //! sequence of the form - //! @code - //! [ - //! f(s1[0], ..., sn[0]), - //! f(s1[1], ..., sn[1]), - //! ... - //! f(s1[M], ..., sn[M]) - //! ] - //! @endcode - //! where `M` is the length of the shortest sequence. Hence, the returned - //! sequence stops when the shortest input sequence is exhausted. If you - //! know that all the sequences you are about to zip have the same length, - //! you should use `zip_with` instead, since it can be more optimized. - //! Also note that it is an error to provide no sequence at all, i.e. - //! `zip_shortest_with` expects at least one sequence. - //! - //! - //! Example - //! ------- - //! @include example/zip_shortest_with.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto zip_shortest_with = [](auto&& f, auto&& x1, ..., auto&& xn) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct zip_shortest_with_impl : zip_shortest_with_impl<S, when<true>> { }; - - struct zip_shortest_with_t { - template <typename F, typename Xs, typename ...Ys> - constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; - }; - - constexpr zip_shortest_with_t zip_shortest_with{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP diff --git a/contrib/restricted/boost/boost/hana/fwd/zip_with.hpp b/contrib/restricted/boost/boost/hana/fwd/zip_with.hpp deleted file mode 100644 index 3e153a3e6a..0000000000 --- a/contrib/restricted/boost/boost/hana/fwd/zip_with.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*! -@file -Forward declares `boost::hana::zip_with`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_FWD_ZIP_WITH_HPP -#define BOOST_HANA_FWD_ZIP_WITH_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/core/when.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! Zip one sequence or more with a given function. - //! @ingroup group-Sequence - //! - //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, - //! `zip_with` produces a sequence whose `i`-th element is - //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of - //! the `k`-th sequence. In other words, `zip_with` produces a sequence - //! of the form - //! @code - //! [ - //! f(s1[0], ..., sn[0]), - //! f(s1[1], ..., sn[1]), - //! ... - //! f(s1[M], ..., sn[M]) - //! ] - //! @endcode - //! where `M` is the length of the sequences, which are all assumed to - //! have the same length. Assuming the sequences to all have the same size - //! allows the library to perform some optimizations. To zip sequences - //! that may have different lengths, `zip_shortest_with` should be used - //! instead. Also note that it is an error to provide no sequence at all, - //! i.e. `zip_with` expects at least one sequence. - //! - //! - //! Example - //! ------- - //! @include example/zip_with.cpp -#ifdef BOOST_HANA_DOXYGEN_INVOKED - constexpr auto zip_with = [](auto&& f, auto&& x1, ..., auto&& xn) { - return tag-dispatched; - }; -#else - template <typename S, typename = void> - struct zip_with_impl : zip_with_impl<S, when<true>> { }; - - struct zip_with_t { - template <typename F, typename Xs, typename ...Ys> - constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; - }; - - constexpr zip_with_t zip_with{}; -#endif -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_FWD_ZIP_WITH_HPP diff --git a/contrib/restricted/boost/boost/hana/greater.hpp b/contrib/restricted/boost/boost/hana/greater.hpp deleted file mode 100644 index 84f7e23a1a..0000000000 --- a/contrib/restricted/boost/boost/hana/greater.hpp +++ /dev/null @@ -1,71 +0,0 @@ -/*! -@file -Defines `boost::hana::greater`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_GREATER_HPP -#define BOOST_HANA_GREATER_HPP - -#include <boost/hana/fwd/greater.hpp> - -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/concepts.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_than.hpp> // required by fwd decl -#include <boost/hana/if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) greater_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Greater = BOOST_HANA_DISPATCH_IF(decltype(greater_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::greater(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::greater(x, y) requires 'y' to be Orderable"); - #endif - - return Greater::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - template <typename T, typename U, bool condition> - struct greater_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::less(static_cast<Y&&>(y), - static_cast<X&&>(x)); - } - }; - - // Cross-type overload - template <typename T, typename U> - struct greater_impl<T, U, when< - detail::has_nontrivial_common_embedding<Orderable, T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::greater(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_GREATER_HPP diff --git a/contrib/restricted/boost/boost/hana/greater_equal.hpp b/contrib/restricted/boost/boost/hana/greater_equal.hpp deleted file mode 100644 index e9b34d2587..0000000000 --- a/contrib/restricted/boost/boost/hana/greater_equal.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Defines `boost::hana::greater_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_GREATER_EQUAL_HPP -#define BOOST_HANA_GREATER_EQUAL_HPP - -#include <boost/hana/fwd/greater_equal.hpp> - -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/concepts.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_than.hpp> // required by fwd decl -#include <boost/hana/if.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) greater_equal_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using GreaterEqual = BOOST_HANA_DISPATCH_IF( - decltype(greater_equal_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::greater_equal(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::greater_equal(x, y) requires 'y' to be Orderable"); - #endif - - return GreaterEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct greater_equal_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X x, Y y) { - return hana::not_(hana::less(static_cast<X&&>(x), - static_cast<Y&&>(y))); - } - }; - - // Cross-type overload - template <typename T, typename U> - struct greater_equal_impl<T, U, when< - detail::has_nontrivial_common_embedding<Orderable, T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::greater_equal(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_GREATER_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/group.hpp b/contrib/restricted/boost/boost/hana/group.hpp deleted file mode 100644 index 52a3d64f70..0000000000 --- a/contrib/restricted/boost/boost/hana/group.hpp +++ /dev/null @@ -1,158 +0,0 @@ -/*! -@file -Defines `boost::hana::group`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_GROUP_HPP -#define BOOST_HANA_GROUP_HPP - -#include <boost/hana/fwd/group.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/equal.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto group_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Group = BOOST_HANA_DISPATCH_IF(group_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::group(xs) requires 'xs' to be a Sequence"); - #endif - - return Group::apply(static_cast<Xs&&>(xs)); - } - - template <typename Xs, typename Predicate> - constexpr auto group_t::operator()(Xs&& xs, Predicate&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Group = BOOST_HANA_DISPATCH_IF(group_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::group(xs, predicate) requires 'xs' to be a Sequence"); - #endif - - return Group::apply(static_cast<Xs&&>(xs), - static_cast<Predicate&&>(pred)); - } - //! @endcond - - namespace detail { - template <typename Xs, std::size_t ...i> - constexpr auto get_subsequence_(Xs&& xs, std::index_sequence<i...>) { - using S = typename hana::tag_of<Xs>::type; - return hana::make<S>(hana::at_c<i>(static_cast<Xs&&>(xs))...); - } - - template <std::size_t offset, typename Indices> - struct offset_by; - - template <std::size_t offset, std::size_t ...i> - struct offset_by<offset, std::index_sequence<i...>> { - using type = std::index_sequence<(offset + i)...>; - }; - - template <bool ...b> - struct group_indices { - static constexpr bool bs[sizeof...(b)] = {b...}; - static constexpr std::size_t n_groups = - detail::count(bs, bs + sizeof(bs), false) + 1; - - static constexpr auto compute_info() { - detail::array<std::size_t, n_groups> sizes{}, offsets{}; - for (std::size_t g = 0, i = 0, offset = 0; g < n_groups; ++g) { - offsets[g] = offset; - - sizes[g] = 1; - while (i < sizeof...(b) && bs[i++]) - ++sizes[g]; - - offset += sizes[g]; - } - return std::make_pair(offsets, sizes); - } - - static constexpr auto info = compute_info(); - static constexpr auto group_offsets = info.first; - static constexpr auto group_sizes = info.second; - - template <typename S, typename Xs, std::size_t ...i> - static constexpr auto finish(Xs&& xs, std::index_sequence<i...>) { - return hana::make<S>( - detail::get_subsequence_( - static_cast<Xs&&>(xs), - typename offset_by< - group_offsets[i], - std::make_index_sequence<group_sizes[i]> - >::type{} - )... - ); - } - }; - } // end namespace detail - - template <typename S, bool condition> - struct group_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred, std::size_t ...i> - static constexpr auto - group_helper(Xs&& xs, Pred&& pred, std::index_sequence<0, i...>) { - using info = detail::group_indices<static_cast<bool>(decltype( - pred(hana::at_c<i - 1>(static_cast<Xs&&>(xs)), - hana::at_c<i>(static_cast<Xs&&>(xs))) - )::value)...>; - return info::template finish<S>(static_cast<Xs&&>(xs), - std::make_index_sequence<info::n_groups>{} - ); - } - - template <typename Xs, typename Pred> - static constexpr auto - group_helper(Xs&& xs, Pred&&, std::index_sequence<0>) { - return hana::make<S>(static_cast<Xs&&>(xs)); - } - - template <typename Xs, typename Pred> - static constexpr auto - group_helper(Xs&&, Pred&&, std::index_sequence<>) { - return hana::make<S>(); - } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - constexpr std::size_t len = decltype(hana::length(xs))::value; - return group_helper(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred), - std::make_index_sequence<len>{}); - } - - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return group_impl::apply(static_cast<Xs&&>(xs), hana::equal); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_GROUP_HPP diff --git a/contrib/restricted/boost/boost/hana/hash.hpp b/contrib/restricted/boost/boost/hana/hash.hpp deleted file mode 100644 index 538ef36eca..0000000000 --- a/contrib/restricted/boost/boost/hana/hash.hpp +++ /dev/null @@ -1,114 +0,0 @@ -/*! -@file -Defines `boost::hana::hash`. - -@copyright Jason Rice 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) - */ - -#ifndef BOOST_HANA_HASH_HPP -#define BOOST_HANA_HASH_HPP - -#include <boost/hana/fwd/hash.hpp> - -#include <boost/hana/concept/hashable.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/fwd/integral_constant.hpp> -#include <boost/hana/type.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X> - constexpr auto hash_t::operator()(X const& x) const { - using Tag = typename hana::tag_of<X>::type; - using Hash = BOOST_HANA_DISPATCH_IF(hash_impl<Tag>, - hana::Hashable<Tag>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Hashable<Tag>::value, - "hana::hash(x) requires 'x' to be Hashable"); -#endif - - return Hash::apply(x); - } - //! @endcond - - template <typename Tag, bool condition> - struct hash_impl<Tag, when<condition>> : default_ { - template <typename X> - static constexpr auto apply(X const&) = delete; - }; - - namespace detail { - template <typename T, typename = void> - struct hash_integral_helper; - - template <typename Member, typename T> - struct hash_integral_helper<Member T::*> { - template <typename X> - static constexpr auto apply(X const&) { - return hana::type_c<hana::integral_constant<Member T::*, X::value>>; - } - }; - - template <typename T> - struct hash_integral_helper<T, - typename std::enable_if<std::is_signed<T>::value>::type - > { - template <typename X> - static constexpr auto apply(X const&) { - constexpr signed long long x = X::value; - return hana::type_c<hana::integral_constant<signed long long, x>>; - } - }; - - template <typename T> - struct hash_integral_helper<T, - typename std::enable_if<std::is_unsigned<T>::value>::type - > { - template <typename X> - static constexpr auto apply(X const&) { - constexpr unsigned long long x = X::value; - return hana::type_c<hana::integral_constant<unsigned long long, x>>; - } - }; - - template <> - struct hash_integral_helper<bool> { - template <typename X> - static constexpr auto apply(X const&) { - return hana::type_c<hana::integral_constant<bool, X::value>>; - } - }; - - template <> - struct hash_integral_helper<char> { - template <typename X> - static constexpr auto apply(X const&) { - using T = std::conditional<std::is_signed<char>::value, - signed long long, unsigned long long - >::type; - constexpr T x = X::value; - return hana::type_c<hana::integral_constant<T, x>>; - } - }; - } - - template <typename Tag> - struct hash_impl<Tag, when<hana::IntegralConstant<Tag>::value>> { - template <typename X> - static constexpr auto apply(X const& x) { - using T = typename std::remove_cv<decltype(X::value)>::type; - return detail::hash_integral_helper<T>::apply(x); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_HASH_HPP diff --git a/contrib/restricted/boost/boost/hana/if.hpp b/contrib/restricted/boost/boost/hana/if.hpp deleted file mode 100644 index 5d7f2bb969..0000000000 --- a/contrib/restricted/boost/boost/hana/if.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Defines `boost::hana::if_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_IF_HPP -#define BOOST_HANA_IF_HPP - -#include <boost/hana/fwd/if.hpp> - -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/eval_if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Cond, typename Then, typename Else> - constexpr decltype(auto) if_t::operator()(Cond&& cond, Then&& then_, Else&& else_) const { - using Bool = typename hana::tag_of<Cond>::type; - using If = BOOST_HANA_DISPATCH_IF(if_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::if_(cond, then, else) requires 'cond' to be a Logical"); - #endif - - return If::apply(static_cast<Cond&&>(cond), - static_cast<Then&&>(then_), - static_cast<Else&&>(else_)); - } - //! @endcond - - namespace detail { - template <typename T> - struct hold { - T value; - constexpr T&& operator()() && { return static_cast<T&&>(value); } - }; - } - - template <typename L, bool condition> - struct if_impl<L, when<condition>> : default_ { - template <typename C, typename T, typename E> - static constexpr auto apply(C&& c, T&& t, E&& e) { - return hana::eval_if(static_cast<C&&>(c), - detail::hold<T&&>{static_cast<T&&>(t)}, - detail::hold<E&&>{static_cast<E&&>(e)} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/index_if.hpp b/contrib/restricted/boost/boost/hana/index_if.hpp deleted file mode 100644 index dfa508a81e..0000000000 --- a/contrib/restricted/boost/boost/hana/index_if.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*! -@file -Defines `boost::hana::index_if`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INDEX_IF_HPP -#define BOOST_HANA_INDEX_IF_HPP - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/index_if.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/basic_tuple.hpp> -#include <boost/hana/fwd/index_if.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/optional.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto index_if_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using IndexIf = BOOST_HANA_DISPATCH_IF(index_if_impl<S>, - hana::Iterable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<S>::value, - "hana::index_if(xs, pred) requires 'xs' to be a Iterable"); - #endif - - return IndexIf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - namespace detail { - template <std::size_t i, std::size_t N, bool Done> - struct iterate_while; - - template <std::size_t i, std::size_t N> - struct iterate_while<i, N, false> { - template <typename Xs, typename Pred> - using f = typename iterate_while<i + 1, N, - static_cast<bool>(detail::decay<decltype( - std::declval<Pred>()( - hana::at(std::declval<Xs>(), hana::size_c<i>)))>::type::value) - >::template f<Xs, Pred>; - }; - - template <std::size_t N> - struct iterate_while<N, N, false> { - template <typename Xs, typename Pred> - using f = hana::optional<>; - }; - - template <std::size_t i, std::size_t N> - struct iterate_while<i, N, true> { - template <typename Xs, typename Pred> - using f = hana::optional<hana::size_t<i - 1>>; - }; - } - - template <typename Tag> - struct index_if_impl<Tag, when<Foldable<Tag>::value>> { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs const& xs, Pred const&) - -> typename detail::iterate_while<0, - decltype(hana::length(xs))::value, false> - ::template f<Xs, Pred> - { return {}; } - }; - - template <typename It> - struct index_if_impl<It, when<!Foldable<It>::value>> { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs const&, Pred const&) - -> typename detail::iterate_while<0, - static_cast<std::size_t>(-1), false> - ::template f<Xs, Pred> - { return {}; } - }; - - // basic_tuple is implemented here to solve circular dependency issues. - template <> - struct index_if_impl<basic_tuple_tag> { - template <typename ...Xs, typename Pred> - static constexpr auto apply(basic_tuple<Xs...> const&, Pred const&) - -> typename detail::index_if<Pred, Xs...>::type - { return {}; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_INDEX_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/insert.hpp b/contrib/restricted/boost/boost/hana/insert.hpp deleted file mode 100644 index 3752a64a29..0000000000 --- a/contrib/restricted/boost/boost/hana/insert.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*! -@file -Defines `boost::hana::insert`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INSERT_HPP -#define BOOST_HANA_INSERT_HPP - -#include <boost/hana/fwd/insert.hpp> - -#include <boost/hana/append.hpp> -#include <boost/hana/concat.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/take_front.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Set, typename ...Args> - constexpr decltype(auto) insert_t::operator()(Set&& set, Args&& ...args) const { - return insert_impl<typename hana::tag_of<Set>::type>::apply( - static_cast<Set&&>(set), - static_cast<Args&&>(args)... - ); - } - //! @endcond - - template <typename T, bool condition> - struct insert_impl<T, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S> - struct insert_impl<S, when<Sequence<S>::value>> { - template <typename Xs, typename N, typename Element> - static constexpr auto apply(Xs&& xs, N const& n, Element&& e) { - return hana::concat(hana::append(hana::take_front(xs, n), - static_cast<Element&&>(e)), - hana::drop_front(xs, n)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_INSERT_HPP diff --git a/contrib/restricted/boost/boost/hana/insert_range.hpp b/contrib/restricted/boost/boost/hana/insert_range.hpp deleted file mode 100644 index 26ad8f765e..0000000000 --- a/contrib/restricted/boost/boost/hana/insert_range.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/*! -@file -Defines `boost::hana::insert_range`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INSERT_RANGE_HPP -#define BOOST_HANA_INSERT_RANGE_HPP - -#include <boost/hana/fwd/insert_range.hpp> - -#include <boost/hana/concat.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/take_front.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N, typename Elements> - constexpr auto insert_range_t::operator()(Xs&& xs, N&& n, Elements&& elements) const { - using S = typename hana::tag_of<Xs>::type; - using InsertRange = BOOST_HANA_DISPATCH_IF(insert_range_impl<S>, - hana::Sequence<Xs>::value && - hana::Foldable<Elements>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<Xs>::value, - "hana::insert_range(xs, n, elements) requires 'xs' to be a Sequence"); - - static_assert(hana::Foldable<Elements>::value, - "hana::insert_range(xs, n, elements) requires 'elements' to be a Foldable"); - #endif - - return InsertRange::apply(static_cast<Xs&&>(xs), - static_cast<N&&>(n), - static_cast<Elements&&>(elements)); - } - //! @endcond - - template <typename S, bool condition> - struct insert_range_impl<S, when<condition>> { - template <typename Xs, typename N, typename Elements> - static constexpr auto apply(Xs&& xs, N const& n, Elements&& e) { - return hana::concat( - hana::concat( - hana::take_front(xs, n), - hana::to<S>(static_cast<Elements&&>(e)) - ), - hana::drop_front(xs, n) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_INSERT_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/integral_constant.hpp b/contrib/restricted/boost/boost/hana/integral_constant.hpp deleted file mode 100644 index edabfe454c..0000000000 --- a/contrib/restricted/boost/boost/hana/integral_constant.hpp +++ /dev/null @@ -1,15 +0,0 @@ -/*! -@file -Defines `boost::hana::integral_constant`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INTEGRAL_CONSTANT_HPP -#define BOOST_HANA_INTEGRAL_CONSTANT_HPP - -#include <boost/hana/bool.hpp> - -#endif // !BOOST_HANA_INTEGRAL_CONSTANT_HPP diff --git a/contrib/restricted/boost/boost/hana/intersection.hpp b/contrib/restricted/boost/boost/hana/intersection.hpp deleted file mode 100644 index a9859d8f42..0000000000 --- a/contrib/restricted/boost/boost/hana/intersection.hpp +++ /dev/null @@ -1,39 +0,0 @@ -/*! -@file -Defines `boost::hana::intersection`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INTERSECTION_HPP -#define BOOST_HANA_INTERSECTION_HPP - -#include <boost/hana/fwd/intersection.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto intersection_t::operator()(Xs&& xs, Ys&& ys) const { - using S = typename hana::tag_of<Xs>::type; - using Intersection = BOOST_HANA_DISPATCH_IF(intersection_impl<S>, - true - ); - - return Intersection::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename S, bool condition> - struct intersection_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_INTERSECTION_HPP diff --git a/contrib/restricted/boost/boost/hana/intersperse.hpp b/contrib/restricted/boost/boost/hana/intersperse.hpp deleted file mode 100644 index 13e8240a13..0000000000 --- a/contrib/restricted/boost/boost/hana/intersperse.hpp +++ /dev/null @@ -1,76 +0,0 @@ -/*! -@file -Defines `boost::hana::intersperse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_INTERSPERSE_HPP -#define BOOST_HANA_INTERSPERSE_HPP - -#include <boost/hana/fwd/intersperse.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Z> - constexpr auto intersperse_t::operator()(Xs&& xs, Z&& z) const { - using S = typename hana::tag_of<Xs>::type; - using Intersperse = BOOST_HANA_DISPATCH_IF(intersperse_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::intersperse(xs, z) requires 'xs' to be a Sequence"); - #endif - - return Intersperse::apply(static_cast<Xs&&>(xs), static_cast<Z&&>(z)); - } - //! @endcond - - template <typename S, bool condition> - struct intersperse_impl<S, when<condition>> : default_ { - template <std::size_t i, typename Xs, typename Z> - static constexpr decltype(auto) - pick(Xs&&, Z&& z, hana::false_ /* odd index */) - { return static_cast<Z&&>(z); } - - template <std::size_t i, typename Xs, typename Z> - static constexpr decltype(auto) - pick(Xs&& xs, Z&&, hana::true_ /* even index */) - { return hana::at_c<(i + 1) / 2>(static_cast<Xs&&>(xs)); } - - template <typename Xs, typename Z, std::size_t ...i> - static constexpr auto - intersperse_helper(Xs&& xs, Z&& z, std::index_sequence<i...>) { - return hana::make<S>( - pick<i>(static_cast<Xs&&>(xs), static_cast<Z&&>(z), - hana::bool_c<(i % 2 == 0)>)... - ); - } - - template <typename Xs, typename Z> - static constexpr auto apply(Xs&& xs, Z&& z) { - constexpr std::size_t size = decltype(hana::length(xs))::value; - constexpr std::size_t new_size = size == 0 ? 0 : (size * 2) - 1; - return intersperse_helper(static_cast<Xs&&>(xs), static_cast<Z&&>(z), - std::make_index_sequence<new_size>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_INTERSPERSE_HPP diff --git a/contrib/restricted/boost/boost/hana/is_disjoint.hpp b/contrib/restricted/boost/boost/hana/is_disjoint.hpp deleted file mode 100644 index c4ffc73121..0000000000 --- a/contrib/restricted/boost/boost/hana/is_disjoint.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Defines `boost::hana::is_disjoint`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_IS_DISJOINT_HPP -#define BOOST_HANA_IS_DISJOINT_HPP - -#include <boost/hana/fwd/is_disjoint.hpp> - -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/contains.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/none_of.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto is_disjoint_t::operator()(Xs&& xs, Ys&& ys) const { - using S1 = typename hana::tag_of<Xs>::type; - using S2 = typename hana::tag_of<Ys>::type; - using IsDisjoint = BOOST_HANA_DISPATCH_IF( - decltype(is_disjoint_impl<S1, S2>{}), - hana::Searchable<S1>::value && - hana::Searchable<S2>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S1>::value, - "hana::is_disjoint(xs, ys) requires 'xs' to be Searchable"); - - static_assert(hana::Searchable<S2>::value, - "hana::is_disjoint(xs, ys) requires 'ys' to be Searchable"); - #endif - - return IsDisjoint::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - namespace detail { - template <typename Ys> - struct in_by_reference { - Ys const& ys; - template <typename X> - constexpr auto operator()(X const& x) const - { return hana::contains(ys, x); } - }; - } - - template <typename S1, typename S2, bool condition> - struct is_disjoint_impl<S1, S2, when<condition>> : default_ { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const& xs, Ys const& ys) { - return hana::none_of(xs, detail::in_by_reference<Ys>{ys}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_IS_DISJOINT_HPP diff --git a/contrib/restricted/boost/boost/hana/is_empty.hpp b/contrib/restricted/boost/boost/hana/is_empty.hpp deleted file mode 100644 index a8b68fa61a..0000000000 --- a/contrib/restricted/boost/boost/hana/is_empty.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Defines `boost::hana::is_empty`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_IS_EMPTY_HPP -#define BOOST_HANA_IS_EMPTY_HPP - -#include <boost/hana/fwd/is_empty.hpp> - -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto is_empty_t::operator()(Xs const& xs) const { - using It = typename hana::tag_of<Xs>::type; - using IsEmpty = BOOST_HANA_DISPATCH_IF(is_empty_impl<It>, - hana::Iterable<It>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It>::value, - "hana::is_empty(xs) requires 'xs' to be an Iterable"); - #endif - - return IsEmpty::apply(xs); - } - //! @endcond - - template <typename It, bool condition> - struct is_empty_impl<It, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_IS_EMPTY_HPP diff --git a/contrib/restricted/boost/boost/hana/is_subset.hpp b/contrib/restricted/boost/boost/hana/is_subset.hpp deleted file mode 100644 index 7ef3e2bed5..0000000000 --- a/contrib/restricted/boost/boost/hana/is_subset.hpp +++ /dev/null @@ -1,84 +0,0 @@ -/*! -@file -Defines `boost::hana::is_subset`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_IS_SUBSET_HPP -#define BOOST_HANA_IS_SUBSET_HPP - -#include <boost/hana/fwd/is_subset.hpp> - -#include <boost/hana/all_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/contains.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/functional/partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto is_subset_t::operator()(Xs&& xs, Ys&& ys) const { - using S1 = typename hana::tag_of<Xs>::type; - using S2 = typename hana::tag_of<Ys>::type; - using IsSubset = BOOST_HANA_DISPATCH_IF( - decltype(is_subset_impl<S1, S2>{}), - hana::Searchable<S1>::value && - hana::Searchable<S2>::value && - !is_default<is_subset_impl<S1, S2>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S1>::value, - "hana::is_subset(xs, ys) requires 'xs' to be Searchable"); - - static_assert(hana::Searchable<S2>::value, - "hana::is_subset(xs, ys) requires 'ys' to be Searchable"); - - static_assert(!is_default<is_subset_impl<S1, S2>>::value, - "hana::is_subset(xs, ys) requires 'xs' and 'ys' to be embeddable " - "in a common Searchable"); - #endif - - return IsSubset::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename S1, typename S2, bool condition> - struct is_subset_impl<S1, S2, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S, bool condition> - struct is_subset_impl<S, S, when<condition>> { - template <typename Xs, typename Ys> - static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { - return hana::all_of(static_cast<Xs&&>(xs), - hana::partial(hana::contains, static_cast<Ys&&>(ys))); - } - }; - - // Cross-type overload - template <typename S1, typename S2> - struct is_subset_impl<S1, S2, when< - detail::has_nontrivial_common_embedding<Searchable, S1, S2>::value - >> { - using C = typename common<S1, S2>::type; - template <typename Xs, typename Ys> - static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { - return hana::is_subset(hana::to<C>(static_cast<Xs&&>(xs)), - hana::to<C>(static_cast<Ys&&>(ys))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_IS_SUBSET_HPP diff --git a/contrib/restricted/boost/boost/hana/keys.hpp b/contrib/restricted/boost/boost/hana/keys.hpp deleted file mode 100644 index b27be1d756..0000000000 --- a/contrib/restricted/boost/boost/hana/keys.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::keys`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_KEYS_HPP -#define BOOST_HANA_KEYS_HPP - -#include <boost/hana/fwd/keys.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Map> - constexpr auto keys_t::operator()(Map&& map) const { - return keys_impl<typename hana::tag_of<Map>::type>::apply( - static_cast<Map&&>(map) - ); - } - //! @endcond - - template <typename T, bool condition> - struct keys_impl<T, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename S> - struct keys_impl<S, when<hana::Struct<S>::value>> { - template <typename Object> - static constexpr auto apply(Object const&) { - return hana::transform(hana::accessors<S>(), hana::first); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_KEYS_HPP diff --git a/contrib/restricted/boost/boost/hana/lazy.hpp b/contrib/restricted/boost/boost/hana/lazy.hpp deleted file mode 100644 index 5cb9a8a3ab..0000000000 --- a/contrib/restricted/boost/boost/hana/lazy.hpp +++ /dev/null @@ -1,229 +0,0 @@ -/*! -@file -Defines `boost::hana::lazy`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LAZY_HPP -#define BOOST_HANA_LAZY_HPP - -#include <boost/hana/fwd/lazy.hpp> - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/monad.hpp> -#include <boost/hana/functional/apply.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/functional/on.hpp> -#include <boost/hana/fwd/ap.hpp> -#include <boost/hana/fwd/duplicate.hpp> -#include <boost/hana/fwd/eval.hpp> -#include <boost/hana/fwd/extend.hpp> -#include <boost/hana/fwd/extract.hpp> -#include <boost/hana/fwd/flatten.hpp> -#include <boost/hana/fwd/lift.hpp> -#include <boost/hana/fwd/transform.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // lazy - ////////////////////////////////////////////////////////////////////////// - template <typename Indices, typename F, typename ...Args> - struct lazy_apply_t; - - namespace detail { struct lazy_secret { }; } - - template <std::size_t ...n, typename F, typename ...Args> - struct lazy_apply_t<std::index_sequence<n...>, F, Args...> - : detail::operators::adl<> - { - template <typename ...T> - constexpr lazy_apply_t(detail::lazy_secret, T&& ...t) - : storage_{static_cast<T&&>(t)...} - { } - - basic_tuple<F, Args...> storage_; - using hana_tag = lazy_tag; - }; - - template <typename X> - struct lazy_value_t : detail::operators::adl<> { - template <typename Y> - constexpr lazy_value_t(detail::lazy_secret, Y&& y) - : storage_{static_cast<Y&&>(y)} - { } - - basic_tuple<X> storage_; - using hana_tag = lazy_tag; - - // If this is called, we assume that `X` is in fact a function. - template <typename ...Args> - constexpr lazy_apply_t< - std::make_index_sequence<sizeof...(Args)>, - X, typename detail::decay<Args>::type... - > operator()(Args&& ...args) const& { - return {detail::lazy_secret{}, - hana::at_c<0>(storage_), static_cast<Args&&>(args)...}; - } - - template <typename ...Args> - constexpr lazy_apply_t< - std::make_index_sequence<sizeof...(Args)>, - X, typename detail::decay<Args>::type... - > operator()(Args&& ...args) && { - return {detail::lazy_secret{}, - static_cast<X&&>(hana::at_c<0>(storage_)), - static_cast<Args&&>(args)... - }; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // make<lazy_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<lazy_tag> { - template <typename X> - static constexpr lazy_value_t<typename detail::decay<X>::type> apply(X&& x) { - return {detail::lazy_secret{}, static_cast<X&&>(x)}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct monad_operators<lazy_tag> { static constexpr bool value = true; }; - } - - ////////////////////////////////////////////////////////////////////////// - // eval for lazy_tag - ////////////////////////////////////////////////////////////////////////// - template <> - struct eval_impl<lazy_tag> { - // lazy_apply_t - template <std::size_t ...n, typename F, typename ...Args> - static constexpr decltype(auto) - apply(lazy_apply_t<std::index_sequence<n...>, F, Args...> const& expr) { - return hana::at_c<0>(expr.storage_)( - hana::at_c<n+1>(expr.storage_)... - ); - } - - template <std::size_t ...n, typename F, typename ...Args> - static constexpr decltype(auto) - apply(lazy_apply_t<std::index_sequence<n...>, F, Args...>& expr) { - return hana::at_c<0>(expr.storage_)( - hana::at_c<n+1>(expr.storage_)... - ); - } - - template <std::size_t ...n, typename F, typename ...Args> - static constexpr decltype(auto) - apply(lazy_apply_t<std::index_sequence<n...>, F, Args...>&& expr) { - return static_cast<F&&>(hana::at_c<0>(expr.storage_))( - static_cast<Args&&>(hana::at_c<n+1>(expr.storage_))... - ); - } - - // lazy_value_t - template <typename X> - static constexpr X const& apply(lazy_value_t<X> const& expr) - { return hana::at_c<0>(expr.storage_); } - - template <typename X> - static constexpr X& apply(lazy_value_t<X>& expr) - { return hana::at_c<0>(expr.storage_); } - - template <typename X> - static constexpr X apply(lazy_value_t<X>&& expr) - { return static_cast<X&&>(hana::at_c<0>(expr.storage_)); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Functor - ////////////////////////////////////////////////////////////////////////// - template <> - struct transform_impl<lazy_tag> { - template <typename Expr, typename F> - static constexpr auto apply(Expr&& expr, F&& f) { - return hana::make_lazy(hana::compose(static_cast<F&&>(f), hana::eval))( - static_cast<Expr&&>(expr) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Applicative - ////////////////////////////////////////////////////////////////////////// - template <> - struct lift_impl<lazy_tag> { - template <typename X> - static constexpr lazy_value_t<typename detail::decay<X>::type> - apply(X&& x) { - return {detail::lazy_secret{}, static_cast<X&&>(x)}; - } - }; - - template <> - struct ap_impl<lazy_tag> { - template <typename F, typename X> - static constexpr decltype(auto) apply(F&& f, X&& x) { - return hana::make_lazy(hana::on(hana::apply, hana::eval))( - static_cast<F&&>(f), static_cast<X&&>(x) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Monad - ////////////////////////////////////////////////////////////////////////// - template <> - struct flatten_impl<lazy_tag> { - template <typename Expr> - static constexpr decltype(auto) apply(Expr&& expr) { - return hana::make_lazy(hana::compose(hana::eval, hana::eval))( - static_cast<Expr&&>(expr) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comonad - ////////////////////////////////////////////////////////////////////////// - template <> - struct extract_impl<lazy_tag> { - template <typename Expr> - static constexpr decltype(auto) apply(Expr&& expr) - { return hana::eval(static_cast<Expr&&>(expr)); } - }; - - template <> - struct duplicate_impl<lazy_tag> { - template <typename Expr> - static constexpr decltype(auto) apply(Expr&& expr) - { return hana::make_lazy(static_cast<Expr&&>(expr)); } - }; - - template <> - struct extend_impl<lazy_tag> { - template <typename Expr, typename F> - static constexpr decltype(auto) apply(Expr&& expr, F&& f) { - return hana::make_lazy(static_cast<F&&>(f))(static_cast<Expr&&>(expr)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LAZY_HPP diff --git a/contrib/restricted/boost/boost/hana/length.hpp b/contrib/restricted/boost/boost/hana/length.hpp deleted file mode 100644 index 44c195b390..0000000000 --- a/contrib/restricted/boost/boost/hana/length.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*! -@file -Defines `boost::hana::length`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LENGTH_HPP -#define BOOST_HANA_LENGTH_HPP - -#include <boost/hana/fwd/length.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto length_t::operator()(Xs const& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Length = BOOST_HANA_DISPATCH_IF(length_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::length(xs) requires 'xs' to be Foldable"); - #endif - - return Length::apply(xs); - } - //! @endcond - - namespace detail { - struct argn { - template <typename ...Xs> - constexpr hana::size_t<sizeof...(Xs)> operator()(Xs const& ...) const - { return {}; } - }; - } - - template <typename T, bool condition> - struct length_impl<T, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs const& xs) { - return hana::unpack(xs, detail::argn{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LENGTH_HPP diff --git a/contrib/restricted/boost/boost/hana/less.hpp b/contrib/restricted/boost/boost/hana/less.hpp deleted file mode 100644 index 05cceabb1d..0000000000 --- a/contrib/restricted/boost/boost/hana/less.hpp +++ /dev/null @@ -1,142 +0,0 @@ -/*! -@file -Defines `boost::hana::less`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LESS_HPP -#define BOOST_HANA_LESS_HPP - -#include <boost/hana/fwd/less.hpp> - -#include <boost/hana/and.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/concept/product.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/concepts.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_than.hpp> // required by fwd decl -#include <boost/hana/equal.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/less_equal.hpp> -#include <boost/hana/lexicographical_compare.hpp> -#include <boost/hana/or.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/value.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr auto less_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Less = BOOST_HANA_DISPATCH_IF(decltype(less_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value && - !is_default<less_impl<T, U>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::less(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::less(x, y) requires 'y' to be Orderable"); - - static_assert(!is_default<less_impl<T, U>>::value, - "hana::less(x, y) requires 'x' and 'y' to be embeddable " - "in a common Orderable"); - #endif - - return Less::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct less_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - // Cross-type overload - template <typename T, typename U> - struct less_impl<T, U, when< - detail::has_nontrivial_common_embedding<Orderable, T, U>::value && - !detail::LessThanComparable<T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::less(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for LessThanComparable data types - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U> - struct less_impl<T, U, when<detail::LessThanComparable<T, U>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) < static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants wrapping an Orderable - ////////////////////////////////////////////////////////////////////////// - template <typename C> - struct less_impl<C, C, when< - hana::Constant<C>::value && - Orderable<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr auto apply(X const&, Y const&) { - constexpr auto is_less = hana::less(hana::value<X>(), hana::value<Y>()); - constexpr bool truth_value = hana::if_(is_less, true, false); - return hana::bool_c<truth_value>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Products - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U> - struct less_impl<T, U, when<hana::Product<T>::value && hana::Product<U>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const& x, Y const& y) { - return hana::or_( - hana::less(hana::first(x), hana::first(y)), - hana::and_( - hana::less_equal(hana::first(x), hana::first(y)), - hana::less(hana::second(x), hana::second(y)) - ) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Sequences - ////////////////////////////////////////////////////////////////////////// - template <typename T, typename U> - struct less_impl<T, U, when< - hana::Sequence<T>::value && hana::Sequence<U>::value - >> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const& xs, Ys const& ys) - { return hana::lexicographical_compare(xs, ys); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LESS_HPP diff --git a/contrib/restricted/boost/boost/hana/less_equal.hpp b/contrib/restricted/boost/boost/hana/less_equal.hpp deleted file mode 100644 index d3d0efe911..0000000000 --- a/contrib/restricted/boost/boost/hana/less_equal.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::less_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LESS_EQUAL_HPP -#define BOOST_HANA_LESS_EQUAL_HPP - -#include <boost/hana/fwd/less_equal.hpp> - -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_than.hpp> // required by fwd decl -#include <boost/hana/less.hpp> -#include <boost/hana/not.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr auto less_equal_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using LessEqual = BOOST_HANA_DISPATCH_IF( - decltype(less_equal_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::less_equal(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::less_equal(x, y) requires 'y' to be Orderable"); - #endif - - return LessEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct less_equal_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::not_(hana::less(static_cast<Y&&>(y), - static_cast<X&&>(x))); - } - }; - - // Cross-type overload - template <typename T, typename U> - struct less_equal_impl<T, U, when< - detail::has_nontrivial_common_embedding<Orderable, T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::less_equal(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LESS_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/lexicographical_compare.hpp b/contrib/restricted/boost/boost/hana/lexicographical_compare.hpp deleted file mode 100644 index e8363ad9f1..0000000000 --- a/contrib/restricted/boost/boost/hana/lexicographical_compare.hpp +++ /dev/null @@ -1,110 +0,0 @@ -/*! -@file -Defines `boost::hana::lexicographical_compare`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP -#define BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP - -#include <boost/hana/fwd/lexicographical_compare.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/drop_front.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/is_empty.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto lexicographical_compare_t::operator()(Xs const& xs, Ys const& ys) const { - return hana::lexicographical_compare(xs, ys, hana::less); - } - - template <typename Xs, typename Ys, typename Pred> - constexpr auto lexicographical_compare_t::operator()(Xs const& xs, Ys const& ys, Pred const& pred) const { - using It1 = typename hana::tag_of<Xs>::type; - using It2 = typename hana::tag_of<Ys>::type; - using LexicographicalCompare = BOOST_HANA_DISPATCH_IF( - lexicographical_compare_impl<It1>, - hana::Iterable<It1>::value && - hana::Iterable<It2>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Iterable<It1>::value, - "hana::lexicographical_compare(xs, ys, pred) requires 'xs' to be Iterable"); - - static_assert(hana::Iterable<It2>::value, - "hana::lexicographical_compare(xs, ys, pred) requires 'ys' to be Iterable"); - #endif - - return LexicographicalCompare::apply(xs, ys, pred); - } - //! @endcond - - template <typename It, bool condition> - struct lexicographical_compare_impl<It, when<condition>> : default_ { - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper2(Xs const&, Ys const&, Pred const&, hana::true_) - { return hana::false_c; } - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper2(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) - { return apply(hana::drop_front(xs), hana::drop_front(ys), pred); } - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper2(Xs const& xs, Ys const& ys, Pred const& pred, bool is_greater) - { return is_greater ? false : apply(hana::drop_front(xs), hana::drop_front(ys), pred); } - - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper1(Xs const&, Ys const&, Pred const&, hana::true_) - { return hana::true_c; } - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper1(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) - { return helper2(xs, ys, pred, hana::if_(pred(hana::front(ys), hana::front(xs)), hana::true_c, hana::false_c)); } - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper1(Xs const& xs, Ys const& ys, Pred const& pred, bool is_less) - { return is_less ? true : helper2(xs, ys, pred, hana::if_(pred(hana::front(ys), hana::front(xs)), hana::true_c, hana::false_c)); } - - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper(Xs const&, Ys const& ys, Pred const&, hana::true_) - { return hana::not_(hana::is_empty(ys)); } - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto - helper(Xs const& xs, Ys const& ys, Pred const& pred, hana::false_) - { return helper1(xs, ys, pred, hana::if_(pred(hana::front(xs), hana::front(ys)), hana::true_c, hana::false_c)); } - - - template <typename Xs, typename Ys, typename Pred> - static constexpr auto apply(Xs const& xs, Ys const& ys, Pred const& pred) { - return helper(xs, ys, pred, hana::bool_c< - decltype(hana::is_empty(xs))::value || - decltype(hana::is_empty(ys))::value - >); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LEXICOGRAPHICAL_COMPARE_HPP diff --git a/contrib/restricted/boost/boost/hana/lift.hpp b/contrib/restricted/boost/boost/hana/lift.hpp deleted file mode 100644 index b8ab3431c2..0000000000 --- a/contrib/restricted/boost/boost/hana/lift.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Defines `boost::hana::lift`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_LIFT_HPP -#define BOOST_HANA_LIFT_HPP - -#include <boost/hana/fwd/lift.hpp> - -#include <boost/hana/concept/applicative.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename A> - struct lift_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Applicative<A>::value, - "hana::lift<A> requires 'A' to be an Applicative"); - #endif - - template <typename X> - constexpr auto operator()(X&& x) const { - using Lift = BOOST_HANA_DISPATCH_IF(lift_impl<A>, - hana::Applicative<A>::value - ); - - return Lift::apply(static_cast<X&&>(x)); - } - }; - - template <typename A, bool condition> - struct lift_impl<A, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...args) = delete; - }; - - template <typename S> - struct lift_impl<S, when<Sequence<S>::value>> { - template <typename X> - static constexpr decltype(auto) apply(X&& x) - { return hana::make<S>(static_cast<X&&>(x)); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_LIFT_HPP diff --git a/contrib/restricted/boost/boost/hana/map.hpp b/contrib/restricted/boost/boost/hana/map.hpp deleted file mode 100644 index 8da5012190..0000000000 --- a/contrib/restricted/boost/boost/hana/map.hpp +++ /dev/null @@ -1,577 +0,0 @@ -/*! -@file -Defines `boost::hana::map`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MAP_HPP -#define BOOST_HANA_MAP_HPP - -#include <boost/hana/fwd/map.hpp> - -#include <boost/hana/all_of.hpp> -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/comparable.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/product.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/contains.hpp> -#include <boost/hana/core/is_a.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/detail/has_duplicates.hpp> -#include <boost/hana/detail/hash_table.hpp> -#include <boost/hana/detail/intrinsics.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/searchable.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/find.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/functional/demux.hpp> -#include <boost/hana/functional/on.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/fwd/any_of.hpp> -#include <boost/hana/fwd/at_key.hpp> -#include <boost/hana/fwd/difference.hpp> -#include <boost/hana/fwd/erase_key.hpp> -#include <boost/hana/fwd/intersection.hpp> -#include <boost/hana/fwd/is_subset.hpp> -#include <boost/hana/fwd/keys.hpp> -#include <boost/hana/fwd/union.hpp> -#include <boost/hana/insert.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/keys.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/remove_if.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/unpack.hpp> -#include <boost/hana/value.hpp> - - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<map_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // map - ////////////////////////////////////////////////////////////////////////// - //! @cond - namespace detail { - template <typename ...> - struct storage_is_default_constructible; - template <typename ...T> - struct storage_is_default_constructible<hana::basic_tuple<T...>> { - static constexpr bool value = detail::fast_and< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(T)... - >::value; - }; - - template <typename ...> - struct storage_is_copy_constructible; - template <typename ...T> - struct storage_is_copy_constructible<hana::basic_tuple<T...>> { - static constexpr bool value = detail::fast_and< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(T, T const&)... - >::value; - }; - - template <typename ...> - struct storage_is_move_constructible; - template <typename ...T> - struct storage_is_move_constructible<hana::basic_tuple<T...>> { - static constexpr bool value = detail::fast_and< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(T, T&&)... - >::value; - }; - - template <typename ...> - struct storage_is_copy_assignable; - template <typename ...T> - struct storage_is_copy_assignable<hana::basic_tuple<T...>> { - static constexpr bool value = detail::fast_and< - BOOST_HANA_TT_IS_ASSIGNABLE(T, T const&)... - >::value; - }; - - template <typename ...> - struct storage_is_move_assignable; - template <typename ...T> - struct storage_is_move_assignable<hana::basic_tuple<T...>> { - static constexpr bool value = detail::fast_and< - BOOST_HANA_TT_IS_ASSIGNABLE(T, T&&)... - >::value; - }; - - template <typename HashTable, typename Storage> - struct map_impl - : detail::searchable_operators<map_impl<HashTable, Storage>> - , detail::operators::adl<map_impl<HashTable, Storage>> - { - using hash_table_type = HashTable; - using storage_type = Storage; - - Storage storage; - - using hana_tag = map_tag; - - template <typename ...P, typename = typename std::enable_if< - std::is_same< - Storage, - hana::basic_tuple<typename detail::decay<P>::type...> - >::value - >::type> - explicit constexpr map_impl(P&& ...pairs) - : storage{static_cast<P&&>(pairs)...} - { } - - explicit constexpr map_impl(Storage&& xs) - : storage(static_cast<Storage&&>(xs)) - { } - - template <typename ...Dummy, typename = typename std::enable_if< - detail::storage_is_default_constructible<Storage, Dummy...>::value - >::type> - constexpr map_impl() - : storage() - { } - - template <typename ...Dummy, typename = typename std::enable_if< - detail::storage_is_copy_constructible<Storage, Dummy...>::value - >::type> - constexpr map_impl(map_impl const& other) - : storage(other.storage) - { } - - template <typename ...Dummy, typename = typename std::enable_if< - detail::storage_is_move_constructible<Storage, Dummy...>::value - >::type> - constexpr map_impl(map_impl&& other) - : storage(static_cast<Storage&&>(other.storage)) - { } - - template <typename ...Dummy, typename = typename std::enable_if< - detail::storage_is_move_assignable<Storage, Dummy...>::value - >::type> - constexpr map_impl& operator=(map_impl&& other) { - storage = static_cast<Storage&&>(other.storage); - return *this; - } - - template <typename ...Dummy, typename = typename std::enable_if< - detail::storage_is_copy_assignable<Storage, Dummy...>::value - >::type> - constexpr map_impl& operator=(map_impl const& other) { - storage = other.storage; - return *this; - } - - // Prevent the compiler from defining the default copy and move - // constructors, which interfere with the SFINAE above. - ~map_impl() = default; - }; - //! @endcond - - template <typename Storage> - struct KeyAtIndex { - template <std::size_t i> - using apply = decltype(hana::first(hana::at_c<i>(std::declval<Storage>()))); - }; - - template <typename ...Pairs> - struct make_map_type { - using Storage = hana::basic_tuple<Pairs...>; - using HashTable = typename detail::make_hash_table< - detail::KeyAtIndex<Storage>::template apply, sizeof...(Pairs) - >::type; - using type = detail::map_impl<HashTable, Storage>; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // make<map_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<map_tag> { - template <typename ...Pairs> - static constexpr auto apply(Pairs&& ...pairs) { -#if defined(BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE) - static_assert(detail::fast_and<hana::Product<Pairs>::value...>::value, - "hana::make_map(pairs...) requires all the 'pairs' to be Products"); - - static_assert(detail::fast_and< - hana::Comparable<decltype(hana::first(pairs))>::value... - >::value, - "hana::make_map(pairs...) requires all the keys to be Comparable"); - - static_assert(detail::fast_and< - hana::Constant< - decltype(hana::equal(hana::first(pairs), hana::first(pairs))) - >::value... - >::value, - "hana::make_map(pairs...) requires all the keys to be " - "Comparable at compile-time"); - - //! @todo - //! This can be implemented more efficiently by doing the check - //! inside each bucket instead. - static_assert(!detail::has_duplicates<decltype(hana::first(pairs))...>::value, - "hana::make_map({keys, values}...) requires all the keys to be unique"); - - static_assert(!detail::has_duplicates<decltype(hana::hash(hana::first(pairs)))...>::value, - "hana::make_map({keys, values}...) requires all the keys to have different hashes"); -#endif - - using Map = typename detail::make_map_type<typename detail::decay<Pairs>::type...>::type; - return Map{hana::make_basic_tuple(static_cast<Pairs&&>(pairs)...)}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // keys - ////////////////////////////////////////////////////////////////////////// - template <> - struct keys_impl<map_tag> { - template <typename Map> - static constexpr decltype(auto) apply(Map&& map) { - return hana::transform(static_cast<Map&&>(map).storage, hana::first); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // values - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename Map> - constexpr decltype(auto) values_t::operator()(Map&& map) const { - return hana::transform(static_cast<Map&&>(map).storage, hana::second); - } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // insert - ////////////////////////////////////////////////////////////////////////// - template <> - struct insert_impl<map_tag> { - template <typename Map, typename Pair> - static constexpr auto helper(Map&& map, Pair&& pair, ...) { - using RawMap = typename std::remove_reference<Map>::type; - using HashTable = typename RawMap::hash_table_type; - using NewHashTable = typename detail::bucket_insert< - HashTable, - decltype(hana::first(pair)), - decltype(hana::length(map.storage))::value - >::type; - - using NewStorage = decltype( - hana::append(static_cast<Map&&>(map).storage, static_cast<Pair&&>(pair)) - ); - return detail::map_impl<NewHashTable, NewStorage>( - hana::append(static_cast<Map&&>(map).storage, static_cast<Pair&&>(pair)) - ); - } - - template <typename Map, typename Pair, std::size_t i> - static constexpr auto - helper(Map&& map, Pair&&, - hana::optional<std::integral_constant<std::size_t, i>>) - { - return static_cast<Map&&>(map); - } - - //! @todo - //! Here, we insert only if the key is not already in the map. - //! This should be handled by `bucket_insert`, and that would also - //! be more efficient. - template <typename Map, typename Pair> - static constexpr auto apply(Map&& map, Pair&& pair) { - using RawMap = typename std::remove_reference<Map>::type; - using Storage = typename RawMap::storage_type; - using HashTable = typename RawMap::hash_table_type; - using Key = decltype(hana::first(pair)); - using MaybeIndex = typename detail::find_index< - HashTable, Key, detail::KeyAtIndex<Storage>::template apply - >::type; - return helper(static_cast<Map&&>(map), static_cast<Pair&&>(pair), MaybeIndex{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // erase_key - ////////////////////////////////////////////////////////////////////////// - template <> - struct erase_key_impl<map_tag> { - //! @todo - //! We could implement some kind of `bucket_erase` metafunction - //! that would be much more efficient than this. - template <typename Map, typename Key> - static constexpr auto - erase_key_helper(Map&& map, Key const&, hana::false_) { - return static_cast<Map&&>(map); - } - - template <typename Map, typename Key> - static constexpr auto - erase_key_helper(Map&& map, Key const& key, hana::true_) { - return hana::unpack( - hana::remove_if(static_cast<Map&&>(map).storage, - hana::on(hana::equal.to(key), hana::first)), - hana::make_map - ); - } - - template <typename Map, typename Key> - static constexpr auto apply_impl(Map&& map, Key const& key, hana::false_) { - return erase_key_helper(static_cast<Map&&>(map), key, - hana::contains(map, key)); - } - - template <typename Map, typename Key> - static constexpr auto apply_impl(Map&& map, Key const&, hana::true_) { - return static_cast<Map&&>(map); - } - - template <typename Map, typename Key> - static constexpr auto apply(Map&& map, Key const& key) { - constexpr bool is_empty = decltype(hana::length(map))::value == 0; - return apply_impl(static_cast<Map&&>(map), key, hana::bool_<is_empty>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<map_tag, map_tag> { - template <typename M1, typename M2> - static constexpr auto equal_helper(M1 const&, M2 const&, hana::false_) { - return hana::false_c; - } - - template <typename M1, typename M2> - static constexpr auto equal_helper(M1 const& m1, M2 const& m2, hana::true_) { - return hana::all_of(hana::keys(m1), hana::demux(equal)( - hana::partial(hana::find, m1), - hana::partial(hana::find, m2) - )); - } - - template <typename M1, typename M2> - static constexpr auto apply(M1 const& m1, M2 const& m2) { - return equal_impl::equal_helper(m1, m2, hana::bool_c< - decltype(hana::length(m1.storage))::value == - decltype(hana::length(m2.storage))::value - >); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Searchable - ////////////////////////////////////////////////////////////////////////// - template <> - struct find_impl<map_tag> { - template <typename Map> - static constexpr auto find_helper(Map&&, ...) { - return hana::nothing; - } - - template <typename Map, std::size_t i> - static constexpr auto - find_helper(Map&& map, hana::optional<std::integral_constant<std::size_t, i>>) { - return hana::just(hana::second(hana::at_c<i>(static_cast<Map&&>(map).storage))); - } - - template <typename Map, typename Key> - static constexpr auto apply(Map&& map, Key const&) { - using RawMap = typename std::remove_reference<Map>::type; - using Storage = typename RawMap::storage_type; - using HashTable = typename RawMap::hash_table_type; - using MaybeIndex = typename detail::find_index< - HashTable, Key, detail::KeyAtIndex<Storage>::template apply - >::type; - return find_helper(static_cast<Map&&>(map), MaybeIndex{}); - } - }; - - template <> - struct find_if_impl<map_tag> { - template <typename M, typename Pred> - static constexpr auto apply(M&& map, Pred&& pred) { - return hana::transform( - hana::find_if(static_cast<M&&>(map).storage, - hana::compose(static_cast<Pred&&>(pred), hana::first)), - hana::second - ); - } - }; - - template <> - struct contains_impl<map_tag> { - template <typename Map, typename Key> - static constexpr auto apply(Map const&, Key const&) { - using RawMap = typename std::remove_reference<Map>::type; - using HashTable = typename RawMap::hash_table_type; - using Storage = typename RawMap::storage_type; - using MaybeIndex = typename detail::find_index< - HashTable, Key, detail::KeyAtIndex<Storage>::template apply - >::type; - return hana::bool_<!decltype(hana::is_nothing(MaybeIndex{}))::value>{}; - } - }; - - template <> - struct any_of_impl<map_tag> { - template <typename M, typename Pred> - static constexpr auto apply(M const& map, Pred const& pred) - { return hana::any_of(hana::keys(map), pred); } - }; - - template <> - struct is_subset_impl<map_tag, map_tag> { - template <typename Ys> - struct all_contained { - Ys const& ys; - template <typename ...X> - constexpr auto operator()(X const& ...x) const { - return hana::bool_c<detail::fast_and< - hana::value<decltype(hana::contains(ys, x))>()... - >::value>; - } - }; - - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const& xs, Ys const& ys) { - auto ys_keys = hana::keys(ys); - return hana::unpack(hana::keys(xs), all_contained<decltype(ys_keys)>{ys_keys}); - } - }; - - template <> - struct at_key_impl<map_tag> { - template <typename Map, typename Key> - static constexpr decltype(auto) apply(Map&& map, Key const&) { - using RawMap = typename std::remove_reference<Map>::type; - using HashTable = typename RawMap::hash_table_type; - using Storage = typename RawMap::storage_type; - using MaybeIndex = typename detail::find_index< - HashTable, Key, detail::KeyAtIndex<Storage>::template apply - >::type; - static_assert(!decltype(hana::is_nothing(MaybeIndex{}))::value, - "hana::at_key(map, key) requires the 'key' to be present in the 'map'"); - constexpr std::size_t index = decltype(*MaybeIndex{}){}(); - return hana::second(hana::at_c<index>(static_cast<Map&&>(map).storage)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // union_ - ////////////////////////////////////////////////////////////////////////// - template <> - struct union_impl<map_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - return hana::fold_left(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), - hana::insert); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // intersection_ - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename Ys> - struct map_insert_if_contains { - Ys const& ys; - - // Second template param will be pair - // Get its key and check if it exists, if it does, insert key, value pair. - template <typename Result, typename Pair> - static constexpr auto helper(Result&& result, Pair&& pair, hana::true_) { - return hana::insert(static_cast<Result&&>(result), static_cast<Pair&&>(pair)); - } - - template <typename Result, typename Pair> - static constexpr auto helper(Result&& result, Pair&&, hana::false_) { - return static_cast<Result&&>(result); - } - - template <typename Result, typename Pair> - constexpr auto operator()(Result&& result, Pair&& pair) const { - constexpr bool keep = hana::value<decltype(hana::contains(ys, hana::first(pair)))>(); - return map_insert_if_contains::helper(static_cast<Result&&>(result), - static_cast<Pair&&>(pair), - hana::bool_c<keep>); - } - }; - } - - template <> - struct intersection_impl<map_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys const& ys) { - return hana::fold_left(static_cast<Xs&&>(xs), hana::make_map(), - detail::map_insert_if_contains<Ys>{ys}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // difference - ////////////////////////////////////////////////////////////////////////// - template <> - struct difference_impl<map_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - return hana::fold_left( - hana::keys(static_cast<Ys&&>(ys)), - static_cast<Xs&&>(xs), - hana::erase_key); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<map_tag> { - template <typename M, typename F> - static constexpr decltype(auto) apply(M&& map, F&& f) { - return hana::unpack(static_cast<M&&>(map).storage, - static_cast<F&&>(f)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Construction from a Foldable - ////////////////////////////////////////////////////////////////////////// - template <typename F> - struct to_impl<map_tag, F, when<hana::Foldable<F>::value>> { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - return hana::fold_left( - static_cast<Xs&&>(xs), hana::make_map(), hana::insert - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MAP_HPP diff --git a/contrib/restricted/boost/boost/hana/max.hpp b/contrib/restricted/boost/boost/hana/max.hpp deleted file mode 100644 index 80889a791c..0000000000 --- a/contrib/restricted/boost/boost/hana/max.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::max`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MAX_HPP -#define BOOST_HANA_MAX_HPP - -#include <boost/hana/fwd/max.hpp> - -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) max_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Max = BOOST_HANA_DISPATCH_IF(decltype(max_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::max(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::max(x, y) requires 'y' to be Orderable"); - #endif - - return Max::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct max_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - decltype(auto) cond = hana::less(x, y); - return hana::if_(static_cast<decltype(cond)&&>(cond), - static_cast<Y&&>(y), - static_cast<X&&>(x) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MAX_HPP diff --git a/contrib/restricted/boost/boost/hana/maximum.hpp b/contrib/restricted/boost/boost/hana/maximum.hpp deleted file mode 100644 index 14cb7abfd4..0000000000 --- a/contrib/restricted/boost/boost/hana/maximum.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*! -@file -Defines `boost::hana::maximum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MAXIMUM_HPP -#define BOOST_HANA_MAXIMUM_HPP - -#include <boost/hana/fwd/maximum.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/fold_left.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr decltype(auto) maximum_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Maximum = BOOST_HANA_DISPATCH_IF(maximum_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::maximum(xs) requires 'xs' to be Foldable"); - #endif - - return Maximum::apply(static_cast<Xs&&>(xs)); - } - - template <typename Xs, typename Predicate> - constexpr decltype(auto) maximum_t::operator()(Xs&& xs, Predicate&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Maximum = BOOST_HANA_DISPATCH_IF(maximum_pred_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::maximum(xs, predicate) requires 'xs' to be Foldable"); - #endif - - return Maximum::apply(static_cast<Xs&&>(xs), - static_cast<Predicate&&>(pred)); - } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // maximum (with a custom predicate) - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename Pred> - struct max_by { - Pred pred; - - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const { - auto result = (*pred)(x, y); - return hana::if_(result, static_cast<Y&&>(y), - static_cast<X&&>(x)); - } - }; - } - - template <typename T, bool condition> - struct maximum_pred_impl<T, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr decltype(auto) apply(Xs&& xs, Pred&& pred) { - // We use a pointer instead of a reference to avoid a Clang ICE. - return hana::fold_left(static_cast<Xs&&>(xs), - detail::max_by<decltype(&pred)>{&pred} - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // maximum (without a custom predicate) - ////////////////////////////////////////////////////////////////////////// - template <typename T, bool condition> - struct maximum_impl<T, when<condition>> : default_ { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) - { return hana::maximum(static_cast<Xs&&>(xs), hana::less); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MAXIMUM_HPP diff --git a/contrib/restricted/boost/boost/hana/members.hpp b/contrib/restricted/boost/boost/hana/members.hpp deleted file mode 100644 index 13a5209288..0000000000 --- a/contrib/restricted/boost/boost/hana/members.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Defines `boost::hana::members`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MEMBERS_HPP -#define BOOST_HANA_MEMBERS_HPP - -#include <boost/hana/fwd/members.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/second.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Object> - constexpr auto members_t::operator()(Object&& object) const { - using S = typename hana::tag_of<Object>::type; - using Members = BOOST_HANA_DISPATCH_IF(members_impl<S>, - hana::Struct<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Struct<S>::value, - "hana::members(object) requires 'object' to be a Struct"); - #endif - - return Members::apply(static_cast<Object&&>(object)); - } - //! @endcond - - namespace struct_detail { - template <typename Holder, typename Forward> - struct members_helper { - Holder object; - template <typename Accessor> - constexpr decltype(auto) operator()(Accessor&& accessor) const { - return hana::second(static_cast<Accessor&&>(accessor))( - static_cast<Forward>(object) - ); - } - }; - } - - template <typename S, bool condition> - struct members_impl<S, when<condition>> : default_ { - template <typename Object> - static constexpr auto apply(Object&& object) { - return hana::transform(hana::accessors<S>(), - struct_detail::members_helper<Object&, Object&&>{object} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MEMBERS_HPP diff --git a/contrib/restricted/boost/boost/hana/min.hpp b/contrib/restricted/boost/boost/hana/min.hpp deleted file mode 100644 index f8c887147b..0000000000 --- a/contrib/restricted/boost/boost/hana/min.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::min`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MIN_HPP -#define BOOST_HANA_MIN_HPP - -#include <boost/hana/fwd/min.hpp> - -#include <boost/hana/concept/orderable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) min_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Min = BOOST_HANA_DISPATCH_IF(decltype(min_impl<T, U>{}), - hana::Orderable<T>::value && - hana::Orderable<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Orderable<T>::value, - "hana::min(x, y) requires 'x' to be Orderable"); - - static_assert(hana::Orderable<U>::value, - "hana::min(x, y) requires 'y' to be Orderable"); - #endif - - return Min::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct min_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - decltype(auto) cond = hana::less(x, y); - return hana::if_(static_cast<decltype(cond)&&>(cond), - static_cast<X&&>(x), - static_cast<Y&&>(y) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MIN_HPP diff --git a/contrib/restricted/boost/boost/hana/minimum.hpp b/contrib/restricted/boost/boost/hana/minimum.hpp deleted file mode 100644 index 8b6f41d8c8..0000000000 --- a/contrib/restricted/boost/boost/hana/minimum.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/*! -@file -Defines `boost::hana::minimum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MINIMUM_HPP -#define BOOST_HANA_MINIMUM_HPP - -#include <boost/hana/fwd/minimum.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/fold_left.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr decltype(auto) minimum_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Minimum = BOOST_HANA_DISPATCH_IF(minimum_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::minimum(xs) requires 'xs' to be Foldable"); - #endif - - return Minimum::apply(static_cast<Xs&&>(xs)); - } - - template <typename Xs, typename Predicate> - constexpr decltype(auto) minimum_t::operator()(Xs&& xs, Predicate&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Minimum = BOOST_HANA_DISPATCH_IF(minimum_pred_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::minimum(xs, predicate) requires 'xs' to be Foldable"); - #endif - - return Minimum::apply(static_cast<Xs&&>(xs), - static_cast<Predicate&&>(pred)); - } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // minimum (with a custom predicate) - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename Pred> - struct min_by { - Pred pred; - - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const { - auto result = (*pred)(x, y); - return hana::if_(result, static_cast<X&&>(x), - static_cast<Y&&>(y)); - } - }; - } - - template <typename T, bool condition> - struct minimum_pred_impl<T, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr decltype(auto) apply(Xs&& xs, Pred const& pred) { - // We use a pointer instead of a reference to avoid a Clang ICE. - return hana::fold_left(static_cast<Xs&&>(xs), - detail::min_by<decltype(&pred)>{&pred} - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // minimum (without a custom predicate) - ////////////////////////////////////////////////////////////////////////// - template <typename T, bool condition> - struct minimum_impl<T, when<condition>> : default_ { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) - { return hana::minimum(static_cast<Xs&&>(xs), hana::less); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MINIMUM_HPP diff --git a/contrib/restricted/boost/boost/hana/minus.hpp b/contrib/restricted/boost/boost/hana/minus.hpp deleted file mode 100644 index 007a3ec24e..0000000000 --- a/contrib/restricted/boost/boost/hana/minus.hpp +++ /dev/null @@ -1,114 +0,0 @@ -/*! -@file -Defines `boost::hana::minus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MINUS_HPP -#define BOOST_HANA_MINUS_HPP - -#include <boost/hana/fwd/minus.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/group.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/fwd/negate.hpp> -#include <boost/hana/plus.hpp> -#include <boost/hana/value.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) minus_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Minus = BOOST_HANA_DISPATCH_IF(decltype(minus_impl<T, U>{}), - hana::Group<T>::value && - hana::Group<U>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Group<T>::value, - "hana::minus(x, y) requires 'x' to be in a Group"); - - static_assert(hana::Group<U>::value, - "hana::minus(x, y) requires 'y' to be in a Group"); - #endif - - return Minus::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct minus_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename T, bool condition> - struct minus_impl<T, T, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::plus(static_cast<X&&>(x), - hana::negate(static_cast<Y&&>(y))); - } - }; - - // Cross-type overload - template <typename T, typename U> - struct minus_impl<T, U, when< - detail::has_nontrivial_common_embedding<Group, T, U>::value - >> { - using C = typename common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::minus(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct minus_impl<T, T, when<std::is_arithmetic<T>::value && - !std::is_same<bool, T>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) - static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Group - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C, typename X, typename Y> - struct constant_from_minus { - static constexpr auto value = hana::minus(hana::value<X>(), hana::value<Y>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct minus_impl<C, C, when< - hana::Constant<C>::value && - Group<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const&, Y const&) - { return hana::to<C>(detail::constant_from_minus<C, X, Y>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MINUS_HPP diff --git a/contrib/restricted/boost/boost/hana/mod.hpp b/contrib/restricted/boost/boost/hana/mod.hpp deleted file mode 100644 index f64b12f211..0000000000 --- a/contrib/restricted/boost/boost/hana/mod.hpp +++ /dev/null @@ -1,107 +0,0 @@ -/*! -@file -Defines `boost::hana::mod`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MOD_HPP -#define BOOST_HANA_MOD_HPP - -#include <boost/hana/fwd/mod.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/euclidean_ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/value.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) mod_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Mod = BOOST_HANA_DISPATCH_IF(decltype(mod_impl<T, U>{}), - hana::EuclideanRing<T>::value && - hana::EuclideanRing<U>::value && - !is_default<mod_impl<T, U>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::EuclideanRing<T>::value, - "hana::mod(x, y) requires 'x' to be an EuclideanRing"); - - static_assert(hana::EuclideanRing<U>::value, - "hana::mod(x, y) requires 'y' to be an EuclideanRing"); - - static_assert(!is_default<mod_impl<T, U>>::value, - "hana::mod(x, y) requires 'x' and 'y' to be embeddable " - "in a common EuclideanRing"); - #endif - - return Mod::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct mod_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - // Cross-type overload - template <typename T, typename U> - struct mod_impl<T, U, when< - detail::has_nontrivial_common_embedding<EuclideanRing, T, U>::value - >> { - using C = typename common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::mod(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for integral data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct mod_impl<T, T, when<std::is_integral<T>::value && - !std::is_same<T, bool>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) % static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over an EuclideanRing - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C, typename X, typename Y> - struct constant_from_mod { - static constexpr auto value = hana::mod(hana::value<X>(), hana::value<Y>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct mod_impl<C, C, when< - hana::Constant<C>::value && - EuclideanRing<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const&, Y const&) - { return hana::to<C>(detail::constant_from_mod<C, X, Y>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MOD_HPP diff --git a/contrib/restricted/boost/boost/hana/monadic_compose.hpp b/contrib/restricted/boost/boost/hana/monadic_compose.hpp deleted file mode 100644 index 064bfc24d3..0000000000 --- a/contrib/restricted/boost/boost/hana/monadic_compose.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines `boost::hana::monadic_compose`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MONADIC_COMPOSE_HPP -#define BOOST_HANA_MONADIC_COMPOSE_HPP - -#include <boost/hana/fwd/monadic_compose.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/partial.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - struct monadic_compose_helper { - template <typename F, typename G, typename X> - constexpr decltype(auto) operator()(F&& f, G&& g, X&& x) const { - using M = typename hana::tag_of<decltype(g(x))>::type; - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::monadic_compose(f, g) requires 'g' to return a monadic value"); - #endif - - return hana::chain(static_cast<G&&>(g)(static_cast<X&&>(x)), - static_cast<F&&>(f)); - } - }; - } - - //! @cond - template <typename F, typename G> - constexpr auto monadic_compose_t::operator()(F&& f, G&& g) const { - return hana::partial(detail::monadic_compose_helper{}, - static_cast<F&&>(f), - static_cast<G&&>(g) - ); - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MONADIC_COMPOSE_HPP diff --git a/contrib/restricted/boost/boost/hana/monadic_fold_left.hpp b/contrib/restricted/boost/boost/hana/monadic_fold_left.hpp deleted file mode 100644 index e06c405604..0000000000 --- a/contrib/restricted/boost/boost/hana/monadic_fold_left.hpp +++ /dev/null @@ -1,132 +0,0 @@ -/*! -@file -Defines `boost::hana::monadic_fold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MONADIC_FOLD_LEFT_HPP -#define BOOST_HANA_MONADIC_FOLD_LEFT_HPP - -#include <boost/hana/fwd/monadic_fold_left.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/fold_right.hpp> -#include <boost/hana/functional/curry.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/lift.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct monadic_fold_left_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::monadic_fold_left<M> requires 'M' to be a Monad"); - #endif - - template <typename Xs, typename State, typename F> - constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::monadic_fold_left<M>(xs, state, f) requires 'xs' to be Foldable"); - #endif - - return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be Foldable"); - #endif - - return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs), - static_cast<F&&>(f)); - } - }; - - namespace detail { - struct foldlM_helper { - template <typename F, typename X, typename K, typename Z> - constexpr decltype(auto) operator()(F&& f, X&& x, K&& k, Z&& z) const { - return hana::chain( - static_cast<F&&>(f)( - static_cast<Z&&>(z), - static_cast<X&&>(x) - ), - static_cast<K&&>(k) - ); - } - }; - - template <typename End, typename M, typename F> - struct monadic_foldl1_helper { - F f; - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const - { return f(static_cast<X&&>(x), static_cast<Y&&>(y)); } - template <typename Y> - constexpr decltype(auto) operator()(End, Y&& y) const - { return hana::lift<M>(static_cast<Y&&>(y)); } - }; - } - - template <typename T, bool condition> - struct monadic_fold_left_impl<T, when<condition>> : default_ { - // with state - template <typename M, typename Xs, typename S, typename F> - static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { - return hana::fold_right( - static_cast<Xs&&>(xs), - hana::lift<M>, - hana::curry<3>(hana::partial( - detail::foldlM_helper{}, static_cast<F&&>(f) - )) - )(static_cast<S&&>(s)); - } - - // without state - template <typename M, typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - struct end { }; - using G = detail::monadic_foldl1_helper<end, M, typename detail::decay<F>::type>; - decltype(auto) result = hana::monadic_fold_left<M>( - static_cast<Xs&&>(xs), - end{}, - G{static_cast<F&&>(f)} - ); - - static_assert(!std::is_same< - std::remove_reference_t<decltype(result)>, - decltype(hana::lift<M>(end{})) - >{}, - "hana::monadic_fold_left<M>(xs, f) requires 'xs' to be non-empty"); - return result; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MONADIC_FOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/monadic_fold_right.hpp b/contrib/restricted/boost/boost/hana/monadic_fold_right.hpp deleted file mode 100644 index 7026b058c3..0000000000 --- a/contrib/restricted/boost/boost/hana/monadic_fold_right.hpp +++ /dev/null @@ -1,131 +0,0 @@ -/*! -@file -Defines `boost::hana::monadic_fold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MONADIC_FOLD_RIGHT_HPP -#define BOOST_HANA_MONADIC_FOLD_RIGHT_HPP - -#include <boost/hana/fwd/monadic_fold_right.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/functional/curry.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/lift.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct monadic_fold_right_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::monadic_fold_right<M> requires 'M' to be a Monad"); - #endif - - template <typename Xs, typename State, typename F> - constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::monadic_fold_right<M>(xs, state, f) requires 'xs' to be Foldable"); - #endif - - return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - - template <typename Xs, typename F> - constexpr decltype(auto) operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using MonadicFoldRight = BOOST_HANA_DISPATCH_IF(monadic_fold_right_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be Foldable"); - #endif - return MonadicFoldRight::template apply<M>(static_cast<Xs&&>(xs), - static_cast<F&&>(f)); - } - }; - - namespace detail { - struct foldrM_helper { - template <typename F, typename K, typename X, typename Z> - constexpr decltype(auto) operator()(F&& f, K&& k, X&& x, Z&& z) const { - return hana::chain( - static_cast<F&&>(f)( - static_cast<X&&>(x), - static_cast<Z&&>(z) - ), - static_cast<K&&>(k) - ); - } - }; - - template <typename End, typename M, typename F> - struct monadic_foldr1_helper { - F f; - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const - { return f(static_cast<X&&>(x), static_cast<Y&&>(y)); } - template <typename X> - constexpr decltype(auto) operator()(X&& x, End) const - { return hana::lift<M>(static_cast<X&&>(x)); } - }; - } - - template <typename T, bool condition> - struct monadic_fold_right_impl<T, when<condition>> : default_ { - // with state - template <typename M, typename Xs, typename S, typename F> - static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) { - return hana::fold_left( - static_cast<Xs&&>(xs), - hana::lift<M>, - hana::curry<3>(hana::partial( - detail::foldrM_helper{}, static_cast<F&&>(f) - )) - )(static_cast<S&&>(s)); - } - - // without state - template <typename M, typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - struct end { }; - using G = detail::monadic_foldr1_helper<end, M, typename detail::decay<F>::type>; - decltype(auto) result = hana::monadic_fold_right<M>( - static_cast<Xs&&>(xs), - end{}, - G{static_cast<F&&>(f)} - ); - - static_assert(!std::is_same< - std::remove_reference_t<decltype(result)>, - decltype(hana::lift<M>(end{})) - >{}, - "hana::monadic_fold_right<M>(xs, f) requires 'xs' to be non-empty"); - return result; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MONADIC_FOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/mult.hpp b/contrib/restricted/boost/boost/hana/mult.hpp deleted file mode 100644 index 9eb89a0cf2..0000000000 --- a/contrib/restricted/boost/boost/hana/mult.hpp +++ /dev/null @@ -1,107 +0,0 @@ -/*! -@file -Defines `boost::hana::mult`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_MULT_HPP -#define BOOST_HANA_MULT_HPP - -#include <boost/hana/fwd/mult.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/value.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) mult_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Mult = BOOST_HANA_DISPATCH_IF(decltype(mult_impl<T, U>{}), - hana::Ring<T>::value && - hana::Ring<U>::value && - !is_default<mult_impl<T, U>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Ring<T>::value, - "hana::mult(x, y) requires 'x' to be in a Ring"); - - static_assert(hana::Ring<U>::value, - "hana::mult(x, y) requires 'y' to be in a Ring"); - - static_assert(!is_default<mult_impl<T, U>>::value, - "hana::mult(x, y) requires 'x' and 'y' to be embeddable " - "in a common Ring"); - #endif - - return Mult::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct mult_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - // Cross-type overload - template <typename T, typename U> - struct mult_impl<T, U, when< - detail::has_nontrivial_common_embedding<Ring, T, U>::value - >> { - using C = typename common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::mult(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for non-boolean arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct mult_impl<T, T, when<std::is_arithmetic<T>::value && - !std::is_same<bool, T>::value>> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) * static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Ring - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C, typename X, typename Y> - struct constant_from_mult { - static constexpr auto value = hana::mult(hana::value<X>(), hana::value<Y>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct mult_impl<C, C, when< - hana::Constant<C>::value && - Ring<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const&, Y const&) - { return hana::to<C>(detail::constant_from_mult<C, X, Y>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_MULT_HPP diff --git a/contrib/restricted/boost/boost/hana/negate.hpp b/contrib/restricted/boost/boost/hana/negate.hpp deleted file mode 100644 index 2b87e7d6a6..0000000000 --- a/contrib/restricted/boost/boost/hana/negate.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Defines `boost::hana::negate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_NEGATE_HPP -#define BOOST_HANA_NEGATE_HPP - -#include <boost/hana/fwd/negate.hpp> - -#include <boost/hana/concept/group.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/fwd/minus.hpp> -#include <boost/hana/zero.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X> - constexpr decltype(auto) negate_t::operator()(X&& x) const { - using G = typename hana::tag_of<X>::type; - using Negate = BOOST_HANA_DISPATCH_IF(negate_impl<G>, - hana::Group<G>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Group<G>::value, - "hana::negate(x) requires 'x' to be in a Group"); - #endif - - return Negate::apply(static_cast<X&&>(x)); - } - //! @endcond - - template <typename T, bool condition> - struct negate_impl<T, when<condition>> : default_ { - template <typename X> - static constexpr decltype(auto) apply(X&& x) - { return hana::minus(hana::zero<T>(), static_cast<X&&>(x)); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct negate_impl<T, when<std::is_arithmetic<T>::value && - !std::is_same<bool, T>::value>> { - template <typename X> - static constexpr decltype(auto) apply(X&& x) - { return -static_cast<X&&>(x); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_NEGATE_HPP diff --git a/contrib/restricted/boost/boost/hana/none.hpp b/contrib/restricted/boost/boost/hana/none.hpp deleted file mode 100644 index 0d8d499dfe..0000000000 --- a/contrib/restricted/boost/boost/hana/none.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*! -@file -Defines `boost::hana::none`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_NONE_HPP -#define BOOST_HANA_NONE_HPP - -#include <boost/hana/fwd/none.hpp> - -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/id.hpp> -#include <boost/hana/none_of.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto none_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using None = BOOST_HANA_DISPATCH_IF(none_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::none(xs) requires 'xs' to be a Searchable"); - #endif - - return None::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename S, bool condition> - struct none_impl<S, when<condition>> : default_ { - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return hana::none_of(static_cast<Xs&&>(xs), hana::id); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_NONE_HPP diff --git a/contrib/restricted/boost/boost/hana/none_of.hpp b/contrib/restricted/boost/boost/hana/none_of.hpp deleted file mode 100644 index 4cf3ffd2d9..0000000000 --- a/contrib/restricted/boost/boost/hana/none_of.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Defines `boost::hana::none_of`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_NONE_OF_HPP -#define BOOST_HANA_NONE_OF_HPP - -#include <boost/hana/fwd/none_of.hpp> - -#include <boost/hana/any_of.hpp> -#include <boost/hana/concept/searchable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto none_of_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using NoneOf = BOOST_HANA_DISPATCH_IF(none_of_impl<S>, - hana::Searchable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Searchable<S>::value, - "hana::none_of(xs, pred) requires 'xs' to be a Searchable"); - #endif - - return NoneOf::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct none_of_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::not_(hana::any_of(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_NONE_OF_HPP diff --git a/contrib/restricted/boost/boost/hana/not.hpp b/contrib/restricted/boost/boost/hana/not.hpp deleted file mode 100644 index 2475f637f1..0000000000 --- a/contrib/restricted/boost/boost/hana/not.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::not_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_NOT_HPP -#define BOOST_HANA_NOT_HPP - -#include <boost/hana/fwd/not.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X> - constexpr decltype(auto) not_t::operator()(X&& x) const { - using Bool = typename hana::tag_of<X>::type; - using Not = BOOST_HANA_DISPATCH_IF(hana::not_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::not_(cond) requires 'cond' to be a Logical"); - #endif - - return Not::apply(static_cast<X&&>(x)); - } - //! @endcond - - template <typename L, bool condition> - struct not_impl<L, when<condition>> : hana::default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename L> - struct not_impl<L, hana::when<std::is_arithmetic<L>::value>> { - template <typename Cond> - static constexpr Cond apply(Cond const& cond) - { return static_cast<Cond>(cond ? false : true); } - }; - - namespace detail { - template <typename C, typename X> - struct constant_from_not { - static constexpr auto value = hana::not_(hana::value<X>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct not_impl<C, hana::when< - hana::Constant<C>::value && - hana::Logical<typename C::value_type>::value - >> { - template <typename Cond> - static constexpr auto apply(Cond const&) - { return hana::to<C>(detail::constant_from_not<C, Cond>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_NOT_HPP diff --git a/contrib/restricted/boost/boost/hana/not_equal.hpp b/contrib/restricted/boost/boost/hana/not_equal.hpp deleted file mode 100644 index 099574bdd0..0000000000 --- a/contrib/restricted/boost/boost/hana/not_equal.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/*! -@file -Defines `boost::hana::not_equal`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_NOT_EQUAL_HPP -#define BOOST_HANA_NOT_EQUAL_HPP - -#include <boost/hana/fwd/not_equal.hpp> - -#include <boost/hana/concept/comparable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> -#include <boost/hana/detail/nested_to.hpp> // required by fwd decl -#include <boost/hana/equal.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr auto not_equal_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using NotEqual = not_equal_impl<T, U>; - return NotEqual::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct not_equal_impl<T, U, when<condition>> : default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::not_(hana::equal(static_cast<X&&>(x), - static_cast<Y&&>(y))); - } - }; - - // Cross-type overload - template <typename T, typename U> - struct not_equal_impl<T, U, when< - detail::has_nontrivial_common_embedding<Comparable, T, U>::value - >> { - using C = typename hana::common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::not_equal(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_NOT_EQUAL_HPP diff --git a/contrib/restricted/boost/boost/hana/one.hpp b/contrib/restricted/boost/boost/hana/one.hpp deleted file mode 100644 index b8d759b8c0..0000000000 --- a/contrib/restricted/boost/boost/hana/one.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/*! -@file -Defines `boost::hana::one`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ONE_HPP -#define BOOST_HANA_ONE_HPP - -#include <boost/hana/fwd/one.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename R> - struct one_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Ring<R>::value, - "hana::one<R>() requires 'R' to be a Ring"); - #endif - - constexpr decltype(auto) operator()() const { - using One = BOOST_HANA_DISPATCH_IF(one_impl<R>, - hana::Ring<R>::value - ); - - return One::apply(); - } - }; - - template <typename R, bool condition> - struct one_impl<R, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for non-boolean arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct one_impl<T, when<std::is_arithmetic<T>::value && - !std::is_same<bool, T>::value>> { - static constexpr T apply() - { return static_cast<T>(1); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Ring - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C> - struct constant_from_one { - static constexpr auto value = hana::one<typename C::value_type>(); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct one_impl<C, when< - hana::Constant<C>::value && - Ring<typename C::value_type>::value - >> { - static constexpr decltype(auto) apply() - { return hana::to<C>(detail::constant_from_one<C>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ONE_HPP diff --git a/contrib/restricted/boost/boost/hana/optional.hpp b/contrib/restricted/boost/boost/hana/optional.hpp deleted file mode 100644 index b3fe78b645..0000000000 --- a/contrib/restricted/boost/boost/hana/optional.hpp +++ /dev/null @@ -1,417 +0,0 @@ -/*! -@file -Defines `boost::hana::optional`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_OPTIONAL_HPP -#define BOOST_HANA_OPTIONAL_HPP - -#include <boost/hana/fwd/optional.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/monad.hpp> -#include <boost/hana/detail/operators/orderable.hpp> -#include <boost/hana/detail/wrong.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/fwd/any_of.hpp> -#include <boost/hana/fwd/ap.hpp> -#include <boost/hana/fwd/concat.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/empty.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/find_if.hpp> -#include <boost/hana/fwd/flatten.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/fwd/lift.hpp> -#include <boost/hana/fwd/transform.hpp> -#include <boost/hana/fwd/type.hpp> -#include <boost/hana/fwd/unpack.hpp> - -#include <cstddef> // std::nullptr_t -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // optional<> - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename T, typename = typename hana::tag_of<T>::type> - struct nested_type { }; - - template <typename T> - struct nested_type<T, type_tag> { using type = typename T::type; }; - } - - template <typename T> - struct optional<T> : detail::operators::adl<>, detail::nested_type<T> { - // 5.3.1, Constructors - constexpr optional() = default; - constexpr optional(optional const&) = default; - constexpr optional(optional&&) = default; - - constexpr optional(T const& t) - : value_(t) - { } - - constexpr optional(T&& t) - : value_(static_cast<T&&>(t)) - { } - - // 5.3.3, Assignment - constexpr optional& operator=(optional const&) = default; - constexpr optional& operator=(optional&&) = default; - - // 5.3.5, Observers - constexpr T const* operator->() const { return &value_; } - constexpr T* operator->() { return &value_; } - - constexpr T& value() & { return value_; } - constexpr T const& value() const& { return value_; } - constexpr T&& value() && { return static_cast<T&&>(value_); } - constexpr T const&& value() const&& { return static_cast<T const&&>(value_); } - - constexpr T& operator*() & { return value_; } - constexpr T const& operator*() const& { return value_; } - constexpr T&& operator*() && { return static_cast<T&&>(value_); } - constexpr T const&& operator*() const&& { return static_cast<T const&&>(value_); } - - template <typename U> constexpr T& value_or(U&&) & { return value_; } - template <typename U> constexpr T const& value_or(U&&) const& { return value_; } - template <typename U> constexpr T&& value_or(U&&) && { return static_cast<T&&>(value_); } - template <typename U> constexpr T const&& value_or(U&&) const&& { return static_cast<T const&&>(value_); } - - // We leave this public because it simplifies the implementation, but - // this should be considered private by users. - T value_; - }; - - //! @cond - template <typename ...dummy> - constexpr auto optional<>::value() const { - static_assert(detail::wrong<dummy...>{}, - "hana::optional::value() requires a non-empty optional"); - } - - template <typename ...dummy> - constexpr auto optional<>::operator*() const { - static_assert(detail::wrong<dummy...>{}, - "hana::optional::operator* requires a non-empty optional"); - } - - template <typename U> - constexpr U&& optional<>::value_or(U&& u) const { - return static_cast<U&&>(u); - } - - template <typename T> - constexpr auto make_just_t::operator()(T&& t) const { - return hana::optional<typename detail::decay<T>::type>(static_cast<T&&>(t)); - } - //! @endcond - - template <typename ...T> - struct tag_of<optional<T...>> { - using type = optional_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // make<optional_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<optional_tag> { - template <typename X> - static constexpr auto apply(X&& x) - { return hana::just(static_cast<X&&>(x)); } - - static constexpr auto apply() - { return hana::nothing; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<optional_tag> { - static constexpr bool value = true; - }; - template <> - struct orderable_operators<optional_tag> { - static constexpr bool value = true; - }; - template <> - struct monad_operators<optional_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // is_just and is_nothing - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename ...T> - constexpr auto is_just_t::operator()(optional<T...> const&) const - { return hana::bool_c<sizeof...(T) != 0>; } - - template <typename ...T> - constexpr auto is_nothing_t::operator()(optional<T...> const&) const - { return hana::bool_c<sizeof...(T) == 0>; } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // sfinae - ////////////////////////////////////////////////////////////////////////// - namespace detail { - struct sfinae_impl { - template <typename F, typename ...X, typename = decltype( - std::declval<F>()(std::declval<X>()...) - )> - constexpr decltype(auto) operator()(int, F&& f, X&& ...x) const { - using Return = decltype(static_cast<F&&>(f)(static_cast<X&&>(x)...)); - static_assert(!std::is_same<Return, void>::value, - "hana::sfinae(f)(args...) requires f(args...) to be non-void"); - - return hana::just(static_cast<F&&>(f)(static_cast<X&&>(x)...)); - } - - template <typename F, typename ...X> - constexpr auto operator()(long, F&&, X&& ...) const - { return hana::nothing; } - }; - } - - //! @cond - template <typename F> - constexpr decltype(auto) sfinae_t::operator()(F&& f) const { - return hana::partial(detail::sfinae_impl{}, int{}, - static_cast<F&&>(f)); - } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<optional_tag, optional_tag> { - template <typename T, typename U> - static constexpr auto apply(hana::optional<T> const& t, hana::optional<U> const& u) - { return hana::equal(t.value_, u.value_); } - - static constexpr hana::true_ apply(hana::optional<> const&, hana::optional<> const&) - { return {}; } - - template <typename T, typename U> - static constexpr hana::false_ apply(T const&, U const&) - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Orderable - ////////////////////////////////////////////////////////////////////////// - template <> - struct less_impl<optional_tag, optional_tag> { - template <typename T> - static constexpr hana::true_ apply(hana::optional<> const&, hana::optional<T> const&) - { return {}; } - - static constexpr hana::false_ apply(hana::optional<> const&, hana::optional<> const&) - { return {}; } - - template <typename T> - static constexpr hana::false_ apply(hana::optional<T> const&, hana::optional<> const&) - { return {}; } - - template <typename T, typename U> - static constexpr auto apply(hana::optional<T> const& x, hana::optional<U> const& y) - { return hana::less(x.value_, y.value_); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Functor - ////////////////////////////////////////////////////////////////////////// - template <> - struct transform_impl<optional_tag> { - template <typename F> - static constexpr auto apply(optional<> const&, F&&) - { return hana::nothing; } - - template <typename T, typename F> - static constexpr auto apply(optional<T> const& opt, F&& f) - { return hana::just(static_cast<F&&>(f)(opt.value_)); } - - template <typename T, typename F> - static constexpr auto apply(optional<T>& opt, F&& f) - { return hana::just(static_cast<F&&>(f)(opt.value_)); } - - template <typename T, typename F> - static constexpr auto apply(optional<T>&& opt, F&& f) - { return hana::just(static_cast<F&&>(f)(static_cast<T&&>(opt.value_))); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Applicative - ////////////////////////////////////////////////////////////////////////// - template <> - struct lift_impl<optional_tag> { - template <typename X> - static constexpr auto apply(X&& x) - { return hana::just(static_cast<X&&>(x)); } - }; - - template <> - struct ap_impl<optional_tag> { - template <typename F, typename X> - static constexpr auto ap_helper(F&&, X&&, ...) - { return hana::nothing; } - - template <typename F, typename X> - static constexpr auto ap_helper(F&& f, X&& x, hana::true_, hana::true_) - { return hana::just(static_cast<F&&>(f).value_(static_cast<X&&>(x).value_)); } - - template <typename F, typename X> - static constexpr auto apply(F&& f, X&& x) { - return ap_impl::ap_helper(static_cast<F&&>(f), static_cast<X&&>(x), - hana::is_just(f), hana::is_just(x)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Monad - ////////////////////////////////////////////////////////////////////////// - template <> - struct flatten_impl<optional_tag> { - static constexpr auto apply(optional<> const&) - { return hana::nothing; } - - static constexpr auto apply(optional<optional<>> const&) - { return hana::nothing; } - - template <typename T> - static constexpr auto apply(optional<optional<T>> const& opt) - { return hana::just(opt.value_.value_); } - - template <typename T> - static constexpr auto apply(optional<optional<T>>&& opt) - { return hana::just(static_cast<T&&>(opt.value_.value_)); } - }; - - ////////////////////////////////////////////////////////////////////////// - // MonadPlus - ////////////////////////////////////////////////////////////////////////// - template <> - struct concat_impl<optional_tag> { - template <typename Y> - static constexpr auto apply(hana::optional<>&, Y&& y) - { return static_cast<Y&&>(y); } - - template <typename Y> - static constexpr auto apply(hana::optional<>&&, Y&& y) - { return static_cast<Y&&>(y); } - - template <typename Y> - static constexpr auto apply(hana::optional<> const&, Y&& y) - { return static_cast<Y&&>(y); } - - template <typename X, typename Y> - static constexpr auto apply(X&& x, Y&&) - { return static_cast<X&&>(x); } - }; - - template <> - struct empty_impl<optional_tag> { - static constexpr auto apply() - { return hana::nothing; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<optional_tag> { - template <typename T, typename F> - static constexpr decltype(auto) apply(optional<T>&& opt, F&& f) - { return static_cast<F&&>(f)(static_cast<T&&>(opt.value_)); } - - template <typename T, typename F> - static constexpr decltype(auto) apply(optional<T> const& opt, F&& f) - { return static_cast<F&&>(f)(opt.value_); } - - template <typename T, typename F> - static constexpr decltype(auto) apply(optional<T>& opt, F&& f) - { return static_cast<F&&>(f)(opt.value_); } - - template <typename F> - static constexpr decltype(auto) apply(optional<> const&, F&& f) - { return static_cast<F&&>(f)(); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Searchable - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <bool> - struct optional_find_if { - template <typename T> - static constexpr auto apply(T const&) - { return hana::nothing; } - }; - - template <> - struct optional_find_if<true> { - template <typename T> - static constexpr auto apply(T&& t) - { return hana::just(static_cast<T&&>(t)); } - }; - } - - template <> - struct find_if_impl<optional_tag> { - template <typename T, typename Pred> - static constexpr auto apply(hana::optional<T> const& opt, Pred&& pred) { - constexpr bool found = decltype(static_cast<Pred&&>(pred)(opt.value_))::value; - return detail::optional_find_if<found>::apply(opt.value_); - } - - template <typename T, typename Pred> - static constexpr auto apply(hana::optional<T>& opt, Pred&& pred) { - constexpr bool found = decltype(static_cast<Pred&&>(pred)(opt.value_))::value; - return detail::optional_find_if<found>::apply(opt.value_); - } - - template <typename T, typename Pred> - static constexpr auto apply(hana::optional<T>&& opt, Pred&& pred) { - constexpr bool found = decltype( - static_cast<Pred&&>(pred)(static_cast<T&&>(opt.value_)) - )::value; - return detail::optional_find_if<found>::apply(static_cast<T&&>(opt.value_)); - } - - template <typename Pred> - static constexpr auto apply(hana::optional<> const&, Pred&&) - { return hana::nothing; } - }; - - template <> - struct any_of_impl<optional_tag> { - template <typename T, typename Pred> - static constexpr auto apply(hana::optional<T> const& opt, Pred&& pred) - { return static_cast<Pred&&>(pred)(opt.value_); } - - template <typename Pred> - static constexpr hana::false_ apply(hana::optional<> const&, Pred&&) - { return {}; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_OPTIONAL_HPP diff --git a/contrib/restricted/boost/boost/hana/or.hpp b/contrib/restricted/boost/boost/hana/or.hpp deleted file mode 100644 index b6aceac0c1..0000000000 --- a/contrib/restricted/boost/boost/hana/or.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Defines `boost::hana::or_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_OR_HPP -#define BOOST_HANA_OR_HPP - -#include <boost/hana/fwd/or.hpp> - -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/variadic/foldl1.hpp> -#include <boost/hana/if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) or_t::operator()(X&& x, Y&& y) const { - using Bool = typename hana::tag_of<X>::type; - using Or = BOOST_HANA_DISPATCH_IF(or_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::or_(x, y) requires 'x' to be a Logical"); - #endif - - return Or::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - - template <typename X, typename ...Y> - constexpr decltype(auto) or_t::operator()(X&& x, Y&& ...y) const { - return detail::variadic::foldl1( - *this, - static_cast<X&&>(x), - static_cast<Y&&>(y)... - ); - } - //! @endcond - - template <typename L, bool condition> - struct or_impl<L, when<condition>> : hana::default_ { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - //! @todo How to forward `x` here? Since the arguments to `if_` - //! can be evaluated in any order, we have to be careful not to - //! use `x` in a moved-from state. - return hana::if_(x, x, static_cast<Y&&>(y)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_OR_HPP diff --git a/contrib/restricted/boost/boost/hana/ordering.hpp b/contrib/restricted/boost/boost/hana/ordering.hpp deleted file mode 100644 index 2e8294a892..0000000000 --- a/contrib/restricted/boost/boost/hana/ordering.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*! -@file -Defines `boost::hana::ordering`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ORDERING_HPP -#define BOOST_HANA_ORDERING_HPP - -#include <boost/hana/fwd/ordering.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/less.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename F> - struct less_by { - F f; - - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) const& - { return hana::less(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } - - template <typename X, typename Y> - constexpr decltype(auto) operator()(X&& x, Y&& y) & - { return hana::less(f(static_cast<X&&>(x)), f(static_cast<Y&&>(y))); } - }; - } - - //! @cond - template <typename F> - constexpr auto ordering_t::operator()(F&& f) const { - return detail::less_by<typename detail::decay<F>::type>{static_cast<F&&>(f)}; - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ORDERING_HPP diff --git a/contrib/restricted/boost/boost/hana/pair.hpp b/contrib/restricted/boost/boost/hana/pair.hpp deleted file mode 100644 index 35ff857269..0000000000 --- a/contrib/restricted/boost/boost/hana/pair.hpp +++ /dev/null @@ -1,207 +0,0 @@ -/*! -@file -Defines `boost::hana::pair`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PAIR_HPP -#define BOOST_HANA_PAIR_HPP - -#include <boost/hana/fwd/pair.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/ebo.hpp> -#include <boost/hana/detail/intrinsics.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/orderable.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/first.hpp> -#include <boost/hana/fwd/second.hpp> - -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <int> struct pix; // pair index - } - - ////////////////////////////////////////////////////////////////////////// - // pair - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename First, typename Second> - struct pair : detail::operators::adl<pair<First, Second>> - , private detail::ebo<detail::pix<0>, First> - , private detail::ebo<detail::pix<1>, Second> - { - // Default constructor - template <typename ...dummy, typename = typename std::enable_if< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, dummy...) && - BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, dummy...) - >::type> - constexpr pair() - : detail::ebo<detail::pix<0>, First>() - , detail::ebo<detail::pix<1>, Second>() - { } - - // Variadic constructors - template <typename ...dummy, typename = typename std::enable_if< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, First const&, dummy...) && - BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, Second const&, dummy...) - >::type> - constexpr pair(First const& fst, Second const& snd) - : detail::ebo<detail::pix<0>, First>(fst) - , detail::ebo<detail::pix<1>, Second>(snd) - { } - - template <typename T, typename U, typename = typename std::enable_if< - BOOST_HANA_TT_IS_CONVERTIBLE(T&&, First) && - BOOST_HANA_TT_IS_CONVERTIBLE(U&&, Second) - >::type> - constexpr pair(T&& t, U&& u) - : detail::ebo<detail::pix<0>, First>(static_cast<T&&>(t)) - , detail::ebo<detail::pix<1>, Second>(static_cast<U&&>(u)) - { } - - - // Possibly converting copy and move constructors - template <typename T, typename U, typename = typename std::enable_if< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, T const&) && - BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, U const&) && - BOOST_HANA_TT_IS_CONVERTIBLE(T const&, First) && - BOOST_HANA_TT_IS_CONVERTIBLE(U const&, Second) - >::type> - constexpr pair(pair<T, U> const& other) - : detail::ebo<detail::pix<0>, First>(hana::first(other)) - , detail::ebo<detail::pix<1>, Second>(hana::second(other)) - { } - - template <typename T, typename U, typename = typename std::enable_if< - BOOST_HANA_TT_IS_CONSTRUCTIBLE(First, T&&) && - BOOST_HANA_TT_IS_CONSTRUCTIBLE(Second, U&&) && - BOOST_HANA_TT_IS_CONVERTIBLE(T&&, First) && - BOOST_HANA_TT_IS_CONVERTIBLE(U&&, Second) - >::type> - constexpr pair(pair<T, U>&& other) - : detail::ebo<detail::pix<0>, First>(hana::first(static_cast<pair<T, U>&&>(other))) - , detail::ebo<detail::pix<1>, Second>(hana::second(static_cast<pair<T, U>&&>(other))) - { } - - - // Copy and move assignment - template <typename T, typename U, typename = typename std::enable_if< - BOOST_HANA_TT_IS_ASSIGNABLE(First&, T const&) && - BOOST_HANA_TT_IS_ASSIGNABLE(Second&, U const&) - >::type> - constexpr pair& operator=(pair<T, U> const& other) { - hana::first(*this) = hana::first(other); - hana::second(*this) = hana::second(other); - return *this; - } - - template <typename T, typename U, typename = typename std::enable_if< - BOOST_HANA_TT_IS_ASSIGNABLE(First&, T&&) && - BOOST_HANA_TT_IS_ASSIGNABLE(Second&, U&&) - >::type> - constexpr pair& operator=(pair<T, U>&& other) { - hana::first(*this) = hana::first(static_cast<pair<T, U>&&>(other)); - hana::second(*this) = hana::second(static_cast<pair<T, U>&&>(other)); - return *this; - } - - // Prevent the compiler from defining the default copy and move - // constructors, which interfere with the SFINAE above. - ~pair() = default; - - friend struct first_impl<pair_tag>; - friend struct second_impl<pair_tag>; - template <typename F, typename S> friend struct pair; - }; - //! @endcond - - template <typename First, typename Second> - struct tag_of<pair<First, Second>> { - using type = pair_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<pair_tag> { - static constexpr bool value = true; - }; - template <> - struct orderable_operators<pair_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Product - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<pair_tag> { - template <typename F, typename S> - static constexpr pair< - typename detail::decay<F>::type, - typename detail::decay<S>::type - > apply(F&& f, S&& s) { - return {static_cast<F&&>(f), static_cast<S&&>(s)}; - } - }; - - template <> - struct first_impl<pair_tag> { - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second>& p) { - return detail::ebo_get<detail::pix<0>>( - static_cast<detail::ebo<detail::pix<0>, First>&>(p) - ); - } - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second> const& p) { - return detail::ebo_get<detail::pix<0>>( - static_cast<detail::ebo<detail::pix<0>, First> const&>(p) - ); - } - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second>&& p) { - return detail::ebo_get<detail::pix<0>>( - static_cast<detail::ebo<detail::pix<0>, First>&&>(p) - ); - } - }; - - template <> - struct second_impl<pair_tag> { - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second>& p) { - return detail::ebo_get<detail::pix<1>>( - static_cast<detail::ebo<detail::pix<1>, Second>&>(p) - ); - } - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second> const& p) { - return detail::ebo_get<detail::pix<1>>( - static_cast<detail::ebo<detail::pix<1>, Second> const&>(p) - ); - } - template <typename First, typename Second> - static constexpr decltype(auto) apply(hana::pair<First, Second>&& p) { - return detail::ebo_get<detail::pix<1>>( - static_cast<detail::ebo<detail::pix<1>, Second>&&>(p) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PAIR_HPP diff --git a/contrib/restricted/boost/boost/hana/partition.hpp b/contrib/restricted/boost/boost/hana/partition.hpp deleted file mode 100644 index e2131f4233..0000000000 --- a/contrib/restricted/boost/boost/hana/partition.hpp +++ /dev/null @@ -1,116 +0,0 @@ -/*! -@file -Defines `boost::hana::partition`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PARTITION_HPP -#define BOOST_HANA_PARTITION_HPP - -#include <boost/hana/fwd/partition.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/pair.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto partition_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Partition = BOOST_HANA_DISPATCH_IF(partition_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::partition(xs, pred) requires 'xs' to be a Sequence"); - #endif - - return Partition::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - namespace detail { - template <bool ...B> - struct partition_indices { - static constexpr detail::array<bool, sizeof...(B)> results{{B...}}; - static constexpr std::size_t left_size = - detail::count(results.begin(), results.end(), true); - static constexpr std::size_t right_size = sizeof...(B) - left_size; - - static constexpr auto compute_left() { - detail::array<std::size_t, left_size> indices{}; - std::size_t* left = &indices[0]; - for (std::size_t i = 0; i < sizeof...(B); ++i) - if (results[i]) - *left++ = i; - return indices; - } - - static constexpr auto compute_right() { - detail::array<std::size_t, right_size> indices{}; - std::size_t* right = &indices[0]; - for (std::size_t i = 0; i < sizeof...(B); ++i) - if (!results[i]) - *right++ = i; - return indices; - } - - static constexpr auto left_indices = compute_left(); - static constexpr auto right_indices = compute_right(); - - template <typename S, typename Xs, std::size_t ...l, std::size_t ...r> - static constexpr auto apply(Xs&& xs, std::index_sequence<l...>, - std::index_sequence<r...>) - { - return hana::make<hana::pair_tag>( - hana::make<S>(hana::at_c<left_indices[l]>(static_cast<Xs&&>(xs))...), - hana::make<S>(hana::at_c<right_indices[r]>(static_cast<Xs&&>(xs))...) - ); - } - }; - - template <typename Pred> - struct deduce_partition_indices { - template <typename ...Xs> - auto operator()(Xs&& ...xs) const -> detail::partition_indices< - static_cast<bool>(detail::decay< - decltype(std::declval<Pred>()(static_cast<Xs&&>(xs))) - >::type::value)... - > { return {}; } - }; - } - - template <typename S, bool condition> - struct partition_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&&) { - using Indices = decltype(hana::unpack( - static_cast<Xs&&>(xs), detail::deduce_partition_indices<Pred&&>{} - )); - return Indices::template apply<S>( - static_cast<Xs&&>(xs), - std::make_index_sequence<Indices::left_size>{}, - std::make_index_sequence<Indices::right_size>{} - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PARTITION_HPP diff --git a/contrib/restricted/boost/boost/hana/permutations.hpp b/contrib/restricted/boost/boost/hana/permutations.hpp deleted file mode 100644 index 601bd71889..0000000000 --- a/contrib/restricted/boost/boost/hana/permutations.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*! -@file -Defines `boost::hana::permutations`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PERMUTATIONS_HPP -#define BOOST_HANA_PERMUTATIONS_HPP - -#include <boost/hana/fwd/permutations.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/array.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto permutations_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Permutations = BOOST_HANA_DISPATCH_IF(permutations_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::permutations(xs) requires 'xs' to be a Sequence"); - #endif - - return Permutations::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - namespace detail { - template <std::size_t N> - struct permutation_indices { - static constexpr auto value = - detail::array<std::size_t, N>{}.iota(0).permutations(); - }; - } - - template <typename S, bool condition> - struct permutations_impl<S, when<condition>> : default_ { - template <std::size_t n, typename Xs, std::size_t ...i> - static constexpr auto - nth_permutation(Xs const& xs, std::index_sequence<i...>) { - constexpr auto indices = detail::permutation_indices<sizeof...(i)>::value; - (void)indices; // workaround GCC warning when sizeof...(i) == 0 - return hana::make<S>(hana::at_c<indices[n][i]>(xs)...); - } - - template <std::size_t N, typename Xs, std::size_t ...n> - static constexpr auto - permutations_helper(Xs const& xs, std::index_sequence<n...>) { - return hana::make<S>(nth_permutation<n>(xs, std::make_index_sequence<N>{})...); - } - - template <typename Xs> - static constexpr auto apply(Xs const& xs) { - constexpr std::size_t N = decltype(hana::length(xs))::value; - constexpr std::size_t total_perms = detail::factorial(N); - return permutations_helper<N>(xs, std::make_index_sequence<total_perms>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PERMUTATIONS_HPP diff --git a/contrib/restricted/boost/boost/hana/plus.hpp b/contrib/restricted/boost/boost/hana/plus.hpp deleted file mode 100644 index bc916773a7..0000000000 --- a/contrib/restricted/boost/boost/hana/plus.hpp +++ /dev/null @@ -1,109 +0,0 @@ -/*! -@file -Defines `boost::hana::plus`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PLUS_HPP -#define BOOST_HANA_PLUS_HPP - -#include <boost/hana/fwd/plus.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/monoid.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> -#include <boost/hana/detail/has_common_embedding.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename Y> - constexpr decltype(auto) plus_t::operator()(X&& x, Y&& y) const { - using T = typename hana::tag_of<X>::type; - using U = typename hana::tag_of<Y>::type; - using Plus = BOOST_HANA_DISPATCH_IF(decltype(plus_impl<T, U>{}), - hana::Monoid<T>::value && - hana::Monoid<U>::value && - !is_default<plus_impl<T, U>>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monoid<T>::value, - "hana::plus(x, y) requires 'x' to be a Monoid"); - - static_assert(hana::Monoid<U>::value, - "hana::plus(x, y) requires 'y' to be a Monoid"); - - static_assert(!is_default<plus_impl<T, U>>::value, - "hana::plus(x, y) requires 'x' and 'y' to be embeddable " - "in a common Monoid"); - #endif - - return Plus::apply(static_cast<X&&>(x), static_cast<Y&&>(y)); - } - //! @endcond - - template <typename T, typename U, bool condition> - struct plus_impl<T, U, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - // Cross-type overload - template <typename T, typename U> - struct plus_impl<T, U, when< - detail::has_nontrivial_common_embedding<Monoid, T, U>::value - >> { - using C = typename common<T, U>::type; - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) { - return hana::plus(hana::to<C>(static_cast<X&&>(x)), - hana::to<C>(static_cast<Y&&>(y))); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for non-boolean arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct plus_impl<T, T, when< - std::is_arithmetic<T>::value && - !std::is_same<T, bool>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X&& x, Y&& y) - { return static_cast<X&&>(x) + static_cast<Y&&>(y); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Monoid - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C, typename X, typename Y> - struct constant_from_plus { - static constexpr auto value = hana::plus(hana::value<X>(), hana::value<Y>()); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct plus_impl<C, C, when< - hana::Constant<C>::value && - Monoid<typename C::value_type>::value - >> { - template <typename X, typename Y> - static constexpr decltype(auto) apply(X const&, Y const&) - { return hana::to<C>(detail::constant_from_plus<C, X, Y>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PLUS_HPP diff --git a/contrib/restricted/boost/boost/hana/power.hpp b/contrib/restricted/boost/boost/hana/power.hpp deleted file mode 100644 index 2a69ebfcaa..0000000000 --- a/contrib/restricted/boost/boost/hana/power.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*! -@file -Defines `boost::hana::power`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_POWER_HPP -#define BOOST_HANA_POWER_HPP - -#include <boost/hana/fwd/power.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/iterate.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/mult.hpp> -#include <boost/hana/one.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename X, typename N> - constexpr decltype(auto) power_t::operator()(X&& x, N const& n) const { - using R = typename hana::tag_of<X>::type; - using Power = BOOST_HANA_DISPATCH_IF(power_impl<R>, - hana::Ring<R>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Ring<R>::value, - "hana::power(x, n) requires 'x' to be in a Ring"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::power(x, n) requires 'n' to be an IntegralConstant"); - #endif - - static_assert(N::value >= 0, - "hana::power(x, n) requires 'n' to be non-negative"); - - return Power::apply(static_cast<X&&>(x), n); - } - //! @endcond - - template <typename R, bool condition> - struct power_impl<R, when<condition>> : default_ { - template <typename X, typename N> - static constexpr decltype(auto) apply(X&& x, N const&) { - constexpr std::size_t n = N::value; - return hana::iterate<n>( - hana::partial(hana::mult, static_cast<X&&>(x)), - hana::one<R>() - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_POWER_HPP diff --git a/contrib/restricted/boost/boost/hana/prefix.hpp b/contrib/restricted/boost/boost/hana/prefix.hpp deleted file mode 100644 index e8b0c21947..0000000000 --- a/contrib/restricted/boost/boost/hana/prefix.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*! -@file -Defines `boost::hana::prefix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PREFIX_HPP -#define BOOST_HANA_PREFIX_HPP - -#include <boost/hana/fwd/prefix.hpp> - -#include <boost/hana/append.hpp> -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/lift.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pref> - constexpr auto prefix_t::operator()(Xs&& xs, Pref&& pref) const { - using M = typename hana::tag_of<Xs>::type; - using Prefix = BOOST_HANA_DISPATCH_IF(prefix_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::prefix(xs, pref) requires 'xs' to be a MonadPlus"); - #endif - - return Prefix::apply(static_cast<Xs&&>(xs), static_cast<Pref&&>(pref)); - } - //! @endcond - - template <typename M, bool condition> - struct prefix_impl<M, when<condition>> : default_ { - template <typename Xs, typename Z> - static constexpr decltype(auto) apply(Xs&& xs, Z&& z) { - return hana::chain(static_cast<Xs&&>(xs), - hana::partial(hana::append, hana::lift<M>(static_cast<Z&&>(z)))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PREFIX_HPP diff --git a/contrib/restricted/boost/boost/hana/prepend.hpp b/contrib/restricted/boost/boost/hana/prepend.hpp deleted file mode 100644 index 825d0b02f6..0000000000 --- a/contrib/restricted/boost/boost/hana/prepend.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Defines `boost::hana::prepend`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PREPEND_HPP -#define BOOST_HANA_PREPEND_HPP - -#include <boost/hana/fwd/prepend.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concat.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/lift.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename X> - constexpr auto prepend_t::operator()(Xs&& xs, X&& x) const { - using M = typename hana::tag_of<Xs>::type; - using Prepend = BOOST_HANA_DISPATCH_IF(prepend_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::prepend(xs, x) requires 'xs' to be a MonadPlus"); - #endif - - return Prepend::apply(static_cast<Xs&&>(xs), static_cast<X&&>(x)); - } - //! @endcond - - template <typename M, bool condition> - struct prepend_impl<M, when<condition>> : default_ { - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - return hana::concat(hana::lift<M>(static_cast<X&&>(x)), - static_cast<Xs&&>(xs)); - } - }; - - template <typename S> - struct prepend_impl<S, when<Sequence<S>::value>> { - template <typename Xs, typename X, std::size_t ...i> - static constexpr auto prepend_helper(Xs&& xs, X&& x, std::index_sequence<i...>) { - return hana::make<S>( - static_cast<X&&>(x), hana::at_c<i>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - constexpr std::size_t N = decltype(hana::length(xs))::value; - return prepend_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), - std::make_index_sequence<N>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PREPEND_HPP diff --git a/contrib/restricted/boost/boost/hana/product.hpp b/contrib/restricted/boost/boost/hana/product.hpp deleted file mode 100644 index 8d3bad9fc3..0000000000 --- a/contrib/restricted/boost/boost/hana/product.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::product`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_PRODUCT_HPP -#define BOOST_HANA_PRODUCT_HPP - -#include <boost/hana/fwd/product.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/ring.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/integral_constant.hpp> // required by fwd decl -#include <boost/hana/mult.hpp> -#include <boost/hana/one.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename R> - struct product_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Ring<R>::value, - "hana::product<R> requires 'R' to be a Ring"); - #endif - - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Product = BOOST_HANA_DISPATCH_IF(product_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::product<R>(xs) requires 'xs' to be Foldable"); - #endif - - return Product::template apply<R>(static_cast<Xs&&>(xs)); - } - }; - - template <typename T, bool condition> - struct product_impl<T, when<condition>> : default_ { - template <typename R, typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - return hana::fold_left(static_cast<Xs&&>(xs), hana::one<R>(), hana::mult); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_PRODUCT_HPP diff --git a/contrib/restricted/boost/boost/hana/range.hpp b/contrib/restricted/boost/boost/hana/range.hpp deleted file mode 100644 index 96a9d02e6a..0000000000 --- a/contrib/restricted/boost/boost/hana/range.hpp +++ /dev/null @@ -1,294 +0,0 @@ -/*! -@file -Defines `boost::hana::range`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_RANGE_HPP -#define BOOST_HANA_RANGE_HPP - -#include <boost/hana/fwd/range.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/common.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/tag_of.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/iterable.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/back.hpp> -#include <boost/hana/fwd/contains.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/drop_front_exactly.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/find.hpp> -#include <boost/hana/fwd/front.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/maximum.hpp> -#include <boost/hana/fwd/minimum.hpp> -#include <boost/hana/fwd/product.hpp> -#include <boost/hana/fwd/sum.hpp> -#include <boost/hana/fwd/unpack.hpp> -#include <boost/hana/integral_constant.hpp> // required by fwd decl and below -#include <boost/hana/optional.hpp> -#include <boost/hana/value.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // range<> - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename T, T From, T To> - struct range - : detail::operators::adl<range<T, From, To>> - , detail::iterable_operators<range<T, From, To>> - { - static_assert(From <= To, - "hana::make_range(from, to) requires 'from <= to'"); - - using value_type = T; - static constexpr value_type from = From; - static constexpr value_type to = To; - }; - //! @endcond - - template <typename T, T From, T To> - struct tag_of<range<T, From, To>> { - using type = range_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // make<range_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<range_tag> { - template <typename From, typename To> - static constexpr auto apply(From const&, To const&) { - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::IntegralConstant<From>::value, - "hana::make_range(from, to) requires 'from' to be an IntegralConstant"); - - static_assert(hana::IntegralConstant<To>::value, - "hana::make_range(from, to) requires 'to' to be an IntegralConstant"); - #endif - - using T = typename common< - typename hana::tag_of<From>::type::value_type, - typename hana::tag_of<To>::type::value_type - >::type; - constexpr T from = hana::to<T>(From::value); - constexpr T to = hana::to<T>(To::value); - return range<T, from, to>{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<range_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<range_tag, range_tag> { - template <typename R1, typename R2> - static constexpr auto apply(R1 const&, R2 const&) { - return hana::bool_c< - (R1::from == R1::to && R2::from == R2::to) || - (R1::from == R2::from && R1::to == R2::to) - >; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<range_tag> { - template <typename T, T from, typename F, T ...v> - static constexpr decltype(auto) - unpack_helper(F&& f, std::integer_sequence<T, v...>) { - return static_cast<F&&>(f)(integral_constant<T, from + v>{}...); - } - - template <typename T, T from, T to, typename F> - static constexpr decltype(auto) apply(range<T, from, to> const&, F&& f) { - return unpack_helper<T, from>(static_cast<F&&>(f), - std::make_integer_sequence<T, to - from>{}); - } - }; - - template <> - struct length_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return hana::size_c<static_cast<std::size_t>(to - from)>; } - }; - - template <> - struct minimum_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return integral_c<T, from>; } - }; - - template <> - struct maximum_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return integral_c<T, to-1>; } - }; - - template <> - struct sum_impl<range_tag> { - // Returns the sum of `[m, n]`, where `m <= n` always hold. - template <typename I> - static constexpr I sum_helper(I m, I n) { - if (m == n) - return m; - - // 0 == m < n - else if (0 == m) - return n * (n+1) / 2; - - // 0 < m < n - else if (0 < m) - return sum_helper(0, n) - sum_helper(0, m-1); - - // m < 0 <= n - else if (0 <= n) - return sum_helper(0, n) - sum_helper(0, -m); - - // m < n < 0 - else - return -sum_helper(-n, -m); - } - - template <typename, typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) { - return integral_c<T, from == to ? 0 : sum_helper(from, to-1)>; - } - }; - - template <> - struct product_impl<range_tag> { - // Returns the product of `[m, n)`, where `m <= n` always hold. - template <typename I> - static constexpr I product_helper(I m, I n) { - if (m <= 0 && 0 < n) - return 0; - else { - I p = 1; - for (; m != n; ++m) - p *= m; - return p; - } - } - - template <typename, typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return integral_c<T, product_helper(from, to)>; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Searchable - ////////////////////////////////////////////////////////////////////////// - template <> - struct find_impl<range_tag> { - template <typename T, T from, typename N> - static constexpr auto find_helper(hana::true_) { - constexpr T n = N::value; - return hana::just(hana::integral_c<T, n>); - } - - template <typename T, T from, typename N> - static constexpr auto find_helper(hana::false_) - { return hana::nothing; } - - template <typename T, T from, T to, typename N> - static constexpr auto apply(range<T, from, to> const&, N const&) { - constexpr auto n = N::value; - return find_helper<T, from, N>(hana::bool_c<(n >= from && n < to)>); - } - }; - - template <> - struct contains_impl<range_tag> { - template <typename T, T from, T to, typename N> - static constexpr auto apply(range<T, from, to> const&, N const&) { - constexpr auto n = N::value; - return bool_c<(n >= from && n < to)>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct front_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return integral_c<T, from>; } - }; - - template <> - struct is_empty_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return bool_c<from == to>; } - }; - - template <> - struct at_impl<range_tag> { - template <typename T, T from, T to, typename N> - static constexpr auto apply(range<T, from, to> const&, N const&) { - constexpr auto n = N::value; - return integral_c<T, from + n>; - } - }; - - template <> - struct back_impl<range_tag> { - template <typename T, T from, T to> - static constexpr auto apply(range<T, from, to> const&) - { return integral_c<T, to - 1>; } - }; - - template <> - struct drop_front_impl<range_tag> { - template <typename T, T from, T to, typename N> - static constexpr auto apply(range<T, from, to> const&, N const&) { - constexpr auto n = N::value; - return range<T, (to < from + n ? to : from + n), to>{}; - } - }; - - template <> - struct drop_front_exactly_impl<range_tag> { - template <typename T, T from, T to, typename N> - static constexpr auto apply(range<T, from, to> const&, N const&) { - constexpr auto n = N::value; - return range<T, from + n, to>{}; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/remove.hpp b/contrib/restricted/boost/boost/hana/remove.hpp deleted file mode 100644 index 7d2925d38e..0000000000 --- a/contrib/restricted/boost/boost/hana/remove.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Defines `boost::hana::remove`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REMOVE_HPP -#define BOOST_HANA_REMOVE_HPP - -#include <boost/hana/fwd/remove.hpp> - -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/filter.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Value> - constexpr auto remove_t::operator()(Xs&& xs, Value&& value) const { - using M = typename hana::tag_of<Xs>::type; - using Remove = BOOST_HANA_DISPATCH_IF(remove_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::remove(xs, value) requires 'xs' to be a MonadPlus"); - #endif - - return Remove::apply(static_cast<Xs&&>(xs), - static_cast<Value&&>(value)); - } - //! @endcond - - template <typename M, bool condition> - struct remove_impl<M, when<condition>> : default_ { - template <typename Xs, typename Value> - static constexpr auto apply(Xs&& xs, Value&& value) { - return hana::filter(static_cast<Xs&&>(xs), - hana::compose(hana::not_, - hana::equal.to(static_cast<Value&&>(value)))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REMOVE_HPP diff --git a/contrib/restricted/boost/boost/hana/remove_at.hpp b/contrib/restricted/boost/boost/hana/remove_at.hpp deleted file mode 100644 index 490ebe8c10..0000000000 --- a/contrib/restricted/boost/boost/hana/remove_at.hpp +++ /dev/null @@ -1,86 +0,0 @@ -/*! -@file -Defines `boost::hana::remove_at` and `boost::hana::remove_at_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REMOVE_AT_HPP -#define BOOST_HANA_REMOVE_AT_HPP - -#include <boost/hana/fwd/remove_at.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto remove_at_t::operator()(Xs&& xs, N const& n) const { - using S = typename hana::tag_of<Xs>::type; - using RemoveAt = BOOST_HANA_DISPATCH_IF(remove_at_impl<S>, - hana::Sequence<S>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::remove_at(xs, n) requires 'xs' to be a Sequence"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::remove_at(xs, n) requires 'n' to be an IntegralConstant"); - #endif - - static_assert(N::value >= 0, - "hana::remove_at(xs, n) requires 'n' to be non-negative"); - - return RemoveAt::apply(static_cast<Xs&&>(xs), n); - } - //! @endcond - - template <typename S, bool condition> - struct remove_at_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...before, std::size_t ...after> - static constexpr auto - remove_at_helper(Xs&& xs, std::index_sequence<before...>, - std::index_sequence<after...>) - { - return hana::make<S>( - hana::at_c<before>(static_cast<Xs&&>(xs))..., - hana::at_c<after + sizeof...(before) + 1>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - static_assert(n < len, - "hana::remove_at(xs, n) requires 'n' to be in the bounds of the sequence"); - return remove_at_helper(static_cast<Xs&&>(xs), - std::make_index_sequence<n>{}, - std::make_index_sequence<len - n - 1>{}); - } - }; - - template <std::size_t n> - struct remove_at_c_t { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const - { return hana::remove_at(static_cast<Xs&&>(xs), hana::size_c<n>); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REMOVE_AT_HPP diff --git a/contrib/restricted/boost/boost/hana/remove_if.hpp b/contrib/restricted/boost/boost/hana/remove_if.hpp deleted file mode 100644 index b379957f3b..0000000000 --- a/contrib/restricted/boost/boost/hana/remove_if.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*! -@file -Defines `boost::hana::remove_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REMOVE_IF_HPP -#define BOOST_HANA_REMOVE_IF_HPP - -#include <boost/hana/fwd/remove_if.hpp> - -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/filter.hpp> -#include <boost/hana/functional/compose.hpp> -#include <boost/hana/not.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto remove_if_t::operator()(Xs&& xs, Pred&& pred) const { - using M = typename hana::tag_of<Xs>::type; - using RemoveIf = BOOST_HANA_DISPATCH_IF(remove_if_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::remove_if(xs, predicate) requires 'xs' to be a MonadPlus"); - #endif - - return RemoveIf::apply(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename M, bool condition> - struct remove_if_impl<M, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::filter(static_cast<Xs&&>(xs), - hana::compose(hana::not_, static_cast<Pred&&>(pred))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REMOVE_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/remove_range.hpp b/contrib/restricted/boost/boost/hana/remove_range.hpp deleted file mode 100644 index 5e46f8ae77..0000000000 --- a/contrib/restricted/boost/boost/hana/remove_range.hpp +++ /dev/null @@ -1,100 +0,0 @@ -/*! -@file -Defines `boost::hana::remove_range` and `boost::hana::remove_range_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REMOVE_RANGE_HPP -#define BOOST_HANA_REMOVE_RANGE_HPP - -#include <boost/hana/fwd/remove_range.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename From, typename To> - constexpr auto remove_range_t::operator()(Xs&& xs, From const& from, To const& to) const { - using S = typename hana::tag_of<Xs>::type; - using RemoveRange = BOOST_HANA_DISPATCH_IF(remove_range_impl<S>, - hana::Sequence<S>::value && - hana::IntegralConstant<From>::value && - hana::IntegralConstant<To>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::remove_range(xs, from, to) requires 'xs' to be a Sequence"); - - static_assert(hana::IntegralConstant<From>::value, - "hana::remove_range(xs, from, to) requires 'from' to be an IntegralConstant"); - - static_assert(hana::IntegralConstant<To>::value, - "hana::remove_range(xs, from, to) requires 'to' to be an IntegralConstant"); - #endif - - return RemoveRange::apply(static_cast<Xs&&>(xs), from, to); - } - //! @endcond - - template <typename S, bool condition> - struct remove_range_impl<S, when<condition>> : default_ { - template <std::size_t offset, typename Xs, std::size_t ...before, std::size_t ...after> - static constexpr auto - remove_range_helper(Xs&& xs, std::index_sequence<before...>, - std::index_sequence<after...>) - { - return hana::make<S>( - hana::at_c<before>(static_cast<Xs&&>(xs))..., - hana::at_c<offset + after>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs, typename From, typename To> - static constexpr auto apply(Xs&& xs, From const&, To const&) { - constexpr std::size_t from = From::value; - constexpr std::size_t to = To::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - constexpr std::size_t before = from == to ? len : from; - constexpr std::size_t after = from == to ? 0 : len - to; - - static_assert(from <= to, - "hana::remove_range(xs, from, to) requires '[from, to)' to be a " - "valid interval, meaning that 'from <= to'"); - static_assert(from == to || from >= 0, - "hana::remove_range(xs, from, to) requires 'from' to be non-negative"); - static_assert(from == to || to <= len, - "hana::remove_range(xs, from, to) requires 'to <= length(xs)'"); - - return remove_range_helper<to>(static_cast<Xs&&>(xs), - std::make_index_sequence<before>{}, - std::make_index_sequence<after>{}); - } - }; - - template <std::size_t from, std::size_t to> - struct remove_range_c_t { - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const { - return hana::remove_range(static_cast<Xs&&>(xs), - hana::size_c<from>, - hana::size_c<to>); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REMOVE_RANGE_HPP diff --git a/contrib/restricted/boost/boost/hana/repeat.hpp b/contrib/restricted/boost/boost/hana/repeat.hpp deleted file mode 100644 index 71854dadbe..0000000000 --- a/contrib/restricted/boost/boost/hana/repeat.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::repeat`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REPEAT_HPP -#define BOOST_HANA_REPEAT_HPP - -#include <boost/hana/fwd/repeat.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename I, bool condition> - struct repeat_impl<I, when<condition>> : default_ { - template <typename F, std::size_t ...i> - static constexpr void repeat_helper(F&& f, std::index_sequence<i...>) { - using Swallow = std::size_t[]; - (void)Swallow{0, ((void)f(), i)...}; - } - - template <typename N, typename F> - static constexpr auto apply(N const&, F&& f) { - static_assert(N::value >= 0, "hana::repeat(n, f) requires 'n' to be non-negative"); - constexpr std::size_t n = N::value; - repeat_helper(static_cast<F&&>(f), std::make_index_sequence<n>{}); - } - }; - - //! @cond - template <typename N, typename F> - constexpr void repeat_t::operator()(N const& n, F&& f) const { - using I = typename hana::tag_of<N>::type; - using Repeat = BOOST_HANA_DISPATCH_IF(repeat_impl<I>, - hana::IntegralConstant<I>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::IntegralConstant<I>::value, - "hana::repeat(n, f) requires 'n' to be an IntegralConstant"); - #endif - - return Repeat::apply(n, static_cast<F&&>(f)); - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REPEAT_HPP diff --git a/contrib/restricted/boost/boost/hana/replace.hpp b/contrib/restricted/boost/boost/hana/replace.hpp deleted file mode 100644 index f797f6de2a..0000000000 --- a/contrib/restricted/boost/boost/hana/replace.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Defines `boost::hana::replace`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REPLACE_HPP -#define BOOST_HANA_REPLACE_HPP - -#include <boost/hana/fwd/replace.hpp> - -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/replace_if.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename OldVal, typename NewVal> - constexpr auto replace_t::operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const { - using S = typename hana::tag_of<Xs>::type; - using Replace = BOOST_HANA_DISPATCH_IF(replace_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::replace(xs, oldval, newval) requires 'xs' to be a Functor"); - #endif - - return Replace::apply(static_cast<Xs&&>(xs), - static_cast<OldVal&&>(oldval), - static_cast<NewVal&&>(newval)); - } - //! @endcond - - template <typename Fun, bool condition> - struct replace_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename OldVal, typename NewVal> - static constexpr decltype(auto) - apply(Xs&& xs, OldVal&& oldval, NewVal&& newval) { - return hana::replace_if( - static_cast<Xs&&>(xs), - hana::equal.to(static_cast<OldVal&&>(oldval)), - static_cast<NewVal&&>(newval) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REPLACE_HPP diff --git a/contrib/restricted/boost/boost/hana/replace_if.hpp b/contrib/restricted/boost/boost/hana/replace_if.hpp deleted file mode 100644 index 026dd61354..0000000000 --- a/contrib/restricted/boost/boost/hana/replace_if.hpp +++ /dev/null @@ -1,54 +0,0 @@ -/*! -@file -Defines `boost::hana::replace_if`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REPLACE_IF_HPP -#define BOOST_HANA_REPLACE_IF_HPP - -#include <boost/hana/fwd/replace_if.hpp> - -#include <boost/hana/adjust_if.hpp> -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/always.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred, typename Value> - constexpr auto replace_if_t::operator()(Xs&& xs, Pred&& pred, Value&& value) const { - using S = typename hana::tag_of<Xs>::type; - using ReplaceIf = BOOST_HANA_DISPATCH_IF(replace_if_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::replace_if(xs, pred, value) requires 'xs' to be a Functor"); - #endif - - return ReplaceIf::apply(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred), - static_cast<Value&&>(value)); - } - //! @endcond - - template <typename Fun, bool condition> - struct replace_if_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename Pred, typename Value> - static constexpr auto apply(Xs&& xs, Pred&& pred, Value&& v) { - return hana::adjust_if(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred), - hana::always(static_cast<Value&&>(v)) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REPLACE_IF_HPP diff --git a/contrib/restricted/boost/boost/hana/replicate.hpp b/contrib/restricted/boost/boost/hana/replicate.hpp deleted file mode 100644 index f04c4d8a44..0000000000 --- a/contrib/restricted/boost/boost/hana/replicate.hpp +++ /dev/null @@ -1,74 +0,0 @@ -/*! -@file -Defines `boost::hana::replicate`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REPLICATE_HPP -#define BOOST_HANA_REPLICATE_HPP - -#include <boost/hana/fwd/replicate.hpp> - -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/cycle.hpp> -#include <boost/hana/lift.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct replicate_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::replicate<M>(x, n) requires 'M' to be a MonadPlus"); - #endif - - template <typename X, typename N> - constexpr auto operator()(X&& x, N const& n) const { - using Replicate = BOOST_HANA_DISPATCH_IF(replicate_impl<M>, - hana::MonadPlus<M>::value && - hana::IntegralConstant<N>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::IntegralConstant<N>::value, - "hana::replicate<M>(x, n) requires 'n' to be an IntegralConstant"); - #endif - - return Replicate::apply(static_cast<X&&>(x), n); - } - }; - - template <typename M, bool condition> - struct replicate_impl<M, when<condition>> : default_ { - template <typename X, typename N> - static constexpr auto apply(X&& x, N const& n) { - return hana::cycle(hana::lift<M>(static_cast<X&&>(x)), n); - } - }; - - template <typename S> - struct replicate_impl<S, when<Sequence<S>::value>> { - template <typename X, std::size_t ...i> - static constexpr auto replicate_helper(X&& x, std::index_sequence<i...>) - { return hana::make<S>(((void)i, x)...); } - - template <typename X, typename N> - static constexpr auto apply(X&& x, N const&) { - constexpr std::size_t n = N::value; - return replicate_helper(static_cast<X&&>(x), - std::make_index_sequence<n>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REPLICATE_HPP diff --git a/contrib/restricted/boost/boost/hana/reverse.hpp b/contrib/restricted/boost/boost/hana/reverse.hpp deleted file mode 100644 index 3e4126963f..0000000000 --- a/contrib/restricted/boost/boost/hana/reverse.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/*! -@file -Defines `boost::hana::reverse`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REVERSE_HPP -#define BOOST_HANA_REVERSE_HPP - -#include <boost/hana/fwd/reverse.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto reverse_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Reverse = BOOST_HANA_DISPATCH_IF(reverse_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::reverse(xs) requires 'xs' to be a Sequence"); - #endif - - return Reverse::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename S, bool condition> - struct reverse_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...i> - static constexpr auto reverse_helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<S>( - hana::at_c<sizeof...(i) - i - 1>(static_cast<Xs&&>(xs))... - ); - } - - template <typename Xs> - static constexpr auto apply(Xs&& xs) { - constexpr std::size_t N = decltype(hana::length(xs))::value; - return reverse_helper(static_cast<Xs&&>(xs), std::make_index_sequence<N>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REVERSE_HPP diff --git a/contrib/restricted/boost/boost/hana/reverse_fold.hpp b/contrib/restricted/boost/boost/hana/reverse_fold.hpp deleted file mode 100644 index 5735a423dd..0000000000 --- a/contrib/restricted/boost/boost/hana/reverse_fold.hpp +++ /dev/null @@ -1,37 +0,0 @@ -/*! -@file -Defines `boost::hana::reverse_fold`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_REVERSE_FOLD_HPP -#define BOOST_HANA_REVERSE_FOLD_HPP - -#include <boost/hana/fwd/reverse_fold.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/fold_right.hpp> -#include <boost/hana/functional/flip.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename S, typename F> - constexpr decltype(auto) reverse_fold_t::operator()(Xs&& xs, S&& s, F&& f) const { - return hana::fold_right(static_cast<Xs&&>(xs), - static_cast<S&&>(s), - hana::flip(static_cast<F&&>(f))); - } - - template <typename Xs, typename F> - constexpr decltype(auto) reverse_fold_t::operator()(Xs&& xs, F&& f) const { - return hana::fold_right(static_cast<Xs&&>(xs), - hana::flip(static_cast<F&&>(f))); - } - //! @endcond -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_REVERSE_FOLD_HPP diff --git a/contrib/restricted/boost/boost/hana/scan_left.hpp b/contrib/restricted/boost/boost/hana/scan_left.hpp deleted file mode 100644 index 2ce4eb5d9d..0000000000 --- a/contrib/restricted/boost/boost/hana/scan_left.hpp +++ /dev/null @@ -1,133 +0,0 @@ -/*! -@file -Defines `boost::hana::scan_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SCAN_LEFT_HPP -#define BOOST_HANA_SCAN_LEFT_HPP - -#include <boost/hana/fwd/scan_left.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/prepend.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr auto scan_left_t::operator()(Xs&& xs, F const& f) const { - using S = typename hana::tag_of<Xs>::type; - using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>, - hana::Sequence<S>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::scan_left(xs, f) requires 'xs' to be a Sequence"); -#endif - - return ScanLeft::apply(static_cast<Xs&&>(xs), f); - } - - template <typename Xs, typename State, typename F> - constexpr auto scan_left_t::operator()(Xs&& xs, State&& state, F const& f) const { - using S = typename hana::tag_of<Xs>::type; - using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>, - hana::Sequence<S>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::scan_left(xs, state, f) requires 'xs' to be a Sequence"); -#endif - - return ScanLeft::apply(static_cast<Xs&&>(xs), - static_cast<State&&>(state), f); - } - //! @endcond - - template <typename S, bool condition> - struct scan_left_impl<S, when<condition>> : default_ { - // Without initial state - template <typename Xs, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> - static constexpr auto - apply1_impl(Xs&& xs, F const& f, std::index_sequence<n1, n2, ns...>) { - static_assert(n1 == 0, "logic error in Boost.Hana: file a bug report"); - - // Use scan_left with the first element as an initial state. - return scan_left_impl::apply_impl( - static_cast<Xs&&>(xs), - hana::at_c<0>(static_cast<Xs&&>(xs)), - f, std::index_sequence<n2, ns...>{} - ); - } - - template <typename Xs, typename F, std::size_t n> - static constexpr auto apply1_impl(Xs&& xs, F const&, std::index_sequence<n>) { - return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))); - } - - template <typename Xs, typename F> - static constexpr auto apply1_impl(Xs&&, F const&, std::index_sequence<>) { - return hana::empty<S>(); - } - - template <typename Xs, typename F> - static constexpr auto apply(Xs&& xs, F const& f) { - constexpr std::size_t Len = decltype(hana::length(xs))::value; - return scan_left_impl::apply1_impl(static_cast<Xs&&>(xs), - f, std::make_index_sequence<Len>{}); - } - - - // With initial state - template <typename Xs, typename State, typename F, - std::size_t n1, std::size_t n2, std::size_t ...ns> - static constexpr auto - apply_impl(Xs&& xs, State&& state, F const& f, - std::index_sequence<n1, n2, ns...>) - { - auto rest = scan_left_impl::apply_impl( - static_cast<Xs&&>(xs), - f(state, hana::at_c<n1>(static_cast<Xs&&>(xs))), - f, std::index_sequence<n2, ns...>{}); - return hana::prepend(std::move(rest), static_cast<State&&>(state)); - } - - template <typename Xs, typename State, typename F, std::size_t n> - static constexpr auto - apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n>) { - auto new_state = f(state, hana::at_c<n>(static_cast<Xs&&>(xs))); - return hana::make<S>(static_cast<State&&>(state), std::move(new_state)); - } - - template <typename Xs, typename State, typename F> - static constexpr auto - apply_impl(Xs&&, State&& state, F const&, std::index_sequence<>) { - return hana::make<S>(static_cast<State&&>(state)); - } - - template <typename Xs, typename State, typename F> - static constexpr auto apply(Xs&& xs, State&& state, F const& f) { - constexpr std::size_t Len = decltype(hana::length(xs))::value; - return scan_left_impl::apply_impl(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - f, std::make_index_sequence<Len>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SCAN_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/scan_right.hpp b/contrib/restricted/boost/boost/hana/scan_right.hpp deleted file mode 100644 index a24eb145ca..0000000000 --- a/contrib/restricted/boost/boost/hana/scan_right.hpp +++ /dev/null @@ -1,130 +0,0 @@ -/*! -@file -Defines `boost::hana::scan_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SCAN_RIGHT_HPP -#define BOOST_HANA_SCAN_RIGHT_HPP - -#include <boost/hana/fwd/scan_right.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/prepend.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr auto scan_right_t::operator()(Xs&& xs, F const& f) const { - using S = typename hana::tag_of<Xs>::type; - using ScanRight = BOOST_HANA_DISPATCH_IF(scan_right_impl<S>, - hana::Sequence<S>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::scan_right(xs, f) requires 'xs' to be a Sequence"); -#endif - - return ScanRight::apply(static_cast<Xs&&>(xs), f); - } - - template <typename Xs, typename State, typename F> - constexpr auto scan_right_t::operator()(Xs&& xs, State&& state, F const& f) const { - using S = typename hana::tag_of<Xs>::type; - using ScanRight = BOOST_HANA_DISPATCH_IF(scan_right_impl<S>, - hana::Sequence<S>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::scan_right(xs, state, f) requires 'xs' to be a Sequence"); -#endif - - return ScanRight::apply(static_cast<Xs&&>(xs), - static_cast<State&&>(state), f); - } - //! @endcond - - template <typename S, bool condition> - struct scan_right_impl<S, when<condition>> : default_ { - // Without initial state - template <typename Xs, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns> - static constexpr auto - apply1_impl(Xs&& xs, F const& f, std::index_sequence<n1, n2, ns...>) { - auto rest = scan_right_impl::apply1_impl(static_cast<Xs&&>(xs), - f, std::index_sequence<n2, ns...>{}); - auto element = f(hana::at_c<n1>(static_cast<Xs&&>(xs)), hana::front(rest)); - return hana::prepend(std::move(rest), std::move(element)); - } - - template <typename Xs, typename F, std::size_t n> - static constexpr auto apply1_impl(Xs&& xs, F const&, std::index_sequence<n>) { - return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))); - } - - template <typename Xs, typename F> - static constexpr auto apply1_impl(Xs&&, F const&, std::index_sequence<>) { - return hana::empty<S>(); - } - - template <typename Xs, typename F> - static constexpr auto apply(Xs&& xs, F const& f) { - constexpr std::size_t Len = decltype(hana::length(xs))::value; - return scan_right_impl::apply1_impl(static_cast<Xs&&>(xs), - f, std::make_index_sequence<Len>{}); - } - - - // With initial state - template <typename Xs, typename State, typename F, - std::size_t n1, std::size_t n2, std::size_t ...ns> - static constexpr auto - apply_impl(Xs&& xs, State&& state, F const& f, - std::index_sequence<n1, n2, ns...>) - { - auto rest = scan_right_impl::apply_impl(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - f, std::index_sequence<n2, ns...>{}); - auto element = f(hana::at_c<n1>(static_cast<Xs&&>(xs)), hana::front(rest)); - return hana::prepend(std::move(rest), std::move(element)); - } - - template <typename Xs, typename State, typename F, std::size_t n> - static constexpr auto - apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n>) { - auto element = f(hana::at_c<n>(static_cast<Xs&&>(xs)), state); - return hana::make<S>(std::move(element), static_cast<State&&>(state)); - } - - template <typename Xs, typename State, typename F> - static constexpr auto - apply_impl(Xs&&, State&& state, F const&, std::index_sequence<>) { - return hana::make<S>(static_cast<State&&>(state)); - } - - template <typename Xs, typename State, typename F> - static constexpr auto apply(Xs&& xs, State&& state, F const& f) { - constexpr std::size_t Len = decltype(hana::length(xs))::value; - return scan_right_impl::apply_impl(static_cast<Xs&&>(xs), - static_cast<State&&>(state), - f, std::make_index_sequence<Len>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SCAN_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/second.hpp b/contrib/restricted/boost/boost/hana/second.hpp deleted file mode 100644 index f17e7a67bf..0000000000 --- a/contrib/restricted/boost/boost/hana/second.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/*! -@file -Defines `boost::hana::second`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SECOND_HPP -#define BOOST_HANA_SECOND_HPP - -#include <boost/hana/fwd/second.hpp> - -#include <boost/hana/concept/product.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Pair> - constexpr decltype(auto) second_t::operator()(Pair&& pair) const { - using P = typename hana::tag_of<Pair>::type; - using Second = BOOST_HANA_DISPATCH_IF(second_impl<P>, - hana::Product<P>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Product<P>::value, - "hana::second(pair) requires 'pair' to be a Product"); - #endif - - return Second::apply(static_cast<Pair&&>(pair)); - } - //! @endcond - - template <typename P, bool condition> - struct second_impl<P, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SECOND_HPP diff --git a/contrib/restricted/boost/boost/hana/set.hpp b/contrib/restricted/boost/boost/hana/set.hpp deleted file mode 100644 index 58979ed47f..0000000000 --- a/contrib/restricted/boost/boost/hana/set.hpp +++ /dev/null @@ -1,323 +0,0 @@ -/*! -@file -Defines `boost::hana::set`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SET_HPP -#define BOOST_HANA_SET_HPP - -#include <boost/hana/fwd/set.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/comparable.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/hashable.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/contains.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/detail/has_duplicates.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/searchable.hpp> -#include <boost/hana/equal.hpp> -#include <boost/hana/erase_key.hpp> -#include <boost/hana/find_if.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/fwd/any_of.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/difference.hpp> -#include <boost/hana/fwd/intersection.hpp> -#include <boost/hana/fwd/union.hpp> -#include <boost/hana/insert.hpp> -#include <boost/hana/is_subset.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/or.hpp> -#include <boost/hana/remove.hpp> -#include <boost/hana/tuple.hpp> -#include <boost/hana/unpack.hpp> -#include <boost/hana/value.hpp> - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // set - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename ...Xs> - struct set - : detail::operators::adl<set<Xs...>> - , detail::searchable_operators<set<Xs...>> - { - tuple<Xs...> storage; - using hana_tag = set_tag; - static constexpr std::size_t size = sizeof...(Xs); - - explicit constexpr set(tuple<Xs...> const& xs) - : storage(xs) - { } - - explicit constexpr set(tuple<Xs...>&& xs) - : storage(static_cast<tuple<Xs...>&&>(xs)) - { } - - constexpr set() = default; - constexpr set(set const& other) = default; - constexpr set(set&& other) = default; - }; - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<set_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // make<set_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<set_tag> { - template <typename ...Xs> - static constexpr auto apply(Xs&& ...xs) { -#if defined(BOOST_HANA_CONFIG_ENABLE_DEBUG_MODE) - static_assert(detail::fast_and<hana::Comparable<Xs>::value...>::value, - "hana::make_set(xs...) requires all the 'xs' to be Comparable"); - - static_assert(detail::fast_and<hana::Hashable<Xs>::value...>::value, - "hana::make_set(xs...) requires all the 'xs' to be Hashable"); - - static_assert(detail::fast_and< - Constant<decltype(hana::equal(xs, xs))>::value... - >::value, - "hana::make_set(xs...) requires all the 'xs' to be " - "Comparable at compile-time"); - - static_assert(!detail::has_duplicates<Xs&&...>::value, - "hana::make_set(xs...) requires all the 'xs' to be unique"); -#endif - - return set<typename detail::decay<Xs>::type...>{ - hana::make_tuple(static_cast<Xs&&>(xs)...) - }; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<set_tag, set_tag> { - template <typename S1, typename S2> - static constexpr auto equal_helper(S1 const& s1, S2 const& s2, hana::true_) - { return hana::is_subset(s1, s2); } - - template <typename S1, typename S2> - static constexpr auto equal_helper(S1 const&, S2 const&, hana::false_) - { return hana::false_c; } - - template <typename S1, typename S2> - static constexpr decltype(auto) apply(S1&& s1, S2&& s2) { - return equal_impl::equal_helper(s1, s2, hana::bool_c< - decltype(hana::length(s1.storage))::value == - decltype(hana::length(s2.storage))::value - >); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<set_tag> { - template <typename Set, typename F> - static constexpr decltype(auto) apply(Set&& set, F&& f) { - return hana::unpack(static_cast<Set&&>(set).storage, - static_cast<F&&>(f)); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Searchable - ////////////////////////////////////////////////////////////////////////// - template <> - struct find_if_impl<set_tag> { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::find_if(static_cast<Xs&&>(xs).storage, static_cast<Pred&&>(pred)); - } - }; - - template <> - struct any_of_impl<set_tag> { - template <typename Pred> - struct any_of_helper { - Pred const& pred; - template <typename ...X> - constexpr auto operator()(X const& ...x) const { - return hana::or_(pred(x)...); - } - constexpr auto operator()() const { - return hana::false_c; - } - }; - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs const& xs, Pred const& pred) { - return hana::unpack(xs.storage, any_of_helper<Pred>{pred}); - } - }; - - template <> - struct is_subset_impl<set_tag, set_tag> { - template <typename Ys> - struct all_contained { - Ys const& ys; - template <typename ...X> - constexpr auto operator()(X const& ...x) const { - return hana::bool_c<detail::fast_and< - hana::value<decltype(hana::contains(ys, x))>()... - >::value>; - } - }; - - template <typename Xs, typename Ys> - static constexpr auto apply(Xs const& xs, Ys const& ys) { - return hana::unpack(xs, all_contained<Ys>{ys}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Conversions - ////////////////////////////////////////////////////////////////////////// - template <typename F> - struct to_impl<set_tag, F, when<hana::Foldable<F>::value>> { - template <typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - return hana::fold_left(static_cast<Xs&&>(xs), - hana::make_set(), - hana::insert); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // insert - ////////////////////////////////////////////////////////////////////////// - template <> - struct insert_impl<set_tag> { - template <typename Xs, typename X, typename Indices> - static constexpr auto - insert_helper(Xs&& xs, X&&, hana::true_, Indices) { - return static_cast<Xs&&>(xs); - } - - template <typename Xs, typename X, std::size_t ...n> - static constexpr auto - insert_helper(Xs&& xs, X&& x, hana::false_, std::index_sequence<n...>) { - return hana::make_set( - hana::at_c<n>(static_cast<Xs&&>(xs).storage)..., static_cast<X&&>(x) - ); - } - - template <typename Xs, typename X> - static constexpr auto apply(Xs&& xs, X&& x) { - constexpr bool c = hana::value<decltype(hana::contains(xs, x))>(); - constexpr std::size_t size = std::remove_reference<Xs>::type::size; - return insert_helper(static_cast<Xs&&>(xs), static_cast<X&&>(x), - hana::bool_c<c>, std::make_index_sequence<size>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // erase_key - ////////////////////////////////////////////////////////////////////////// - template <> - struct erase_key_impl<set_tag> { - template <typename Xs, typename X> - static constexpr decltype(auto) apply(Xs&& xs, X&& x) { - return hana::unpack( - hana::remove(static_cast<Xs&&>(xs).storage, - static_cast<X&&>(x)), - hana::make_set - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // intersection - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename Ys> - struct set_insert_if_contains { - Ys const& ys; - - template <typename Result, typename Key> - static constexpr auto helper(Result&& result, Key&& key, hana::true_) { - return hana::insert(static_cast<Result&&>(result), static_cast<Key&&>(key)); - } - - template <typename Result, typename Key> - static constexpr auto helper(Result&& result, Key&&, hana::false_) { - return static_cast<Result&&>(result); - } - - template <typename Result, typename Key> - constexpr auto operator()(Result&& result, Key&& key) const { - constexpr bool keep = hana::value<decltype(hana::contains(ys, key))>(); - return set_insert_if_contains::helper(static_cast<Result&&>(result), - static_cast<Key&&>(key), - hana::bool_c<keep>); - } - }; - } - - template <> - struct intersection_impl<set_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys const& ys) { - return hana::fold_left(static_cast<Xs&&>(xs), hana::make_set(), - detail::set_insert_if_contains<Ys>{ys}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // union_ - ////////////////////////////////////////////////////////////////////////// - template <> - struct union_impl<set_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - return hana::fold_left(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys), - hana::insert); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // difference - ////////////////////////////////////////////////////////////////////////// - template <> - struct difference_impl<set_tag> { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - return hana::fold_left(static_cast<Ys&&>(ys), static_cast<Xs&&>(xs), - hana::erase_key); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SET_HPP diff --git a/contrib/restricted/boost/boost/hana/size.hpp b/contrib/restricted/boost/boost/hana/size.hpp deleted file mode 100644 index 762349cb62..0000000000 --- a/contrib/restricted/boost/boost/hana/size.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/*! -@file -Defines `boost::hana::size`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SIZE_HPP -#define BOOST_HANA_SIZE_HPP - -#include <boost/hana/fwd/size.hpp> - -#include <boost/hana/length.hpp> - -#endif // !BOOST_HANA_SIZE_HPP diff --git a/contrib/restricted/boost/boost/hana/slice.hpp b/contrib/restricted/boost/boost/hana/slice.hpp deleted file mode 100644 index 2cc4c7209d..0000000000 --- a/contrib/restricted/boost/boost/hana/slice.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/*! -@file -Defines `boost::hana::slice` and `boost::hana::slice_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SLICE_HPP -#define BOOST_HANA_SLICE_HPP - -#include <boost/hana/fwd/slice.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/range.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Indices> - constexpr auto slice_t::operator()(Xs&& xs, Indices&& indices) const { - using S = typename hana::tag_of<Xs>::type; - using Slice = BOOST_HANA_DISPATCH_IF(slice_impl<S>, - hana::Sequence<S>::value && - hana::Foldable<Indices>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::slice(xs, indices) requires 'xs' to be a Sequence"); - - static_assert(hana::Foldable<Indices>::value, - "hana::slice(xs, indices) requires 'indices' to be Foldable"); - #endif - - return Slice::apply(static_cast<Xs&&>(xs), static_cast<Indices&&>(indices)); - } - //! @endcond - - namespace detail { - template <typename Xs> - struct take_arbitrary { - Xs& xs; - using S = typename hana::tag_of<Xs>::type; - - template <typename ...N> - constexpr auto operator()(N const& ...) const { - return hana::make<S>(hana::at_c<N::value>(xs)...); - } - }; - } - - template <typename S, bool condition> - struct slice_impl<S, when<condition>> : default_ { - template <std::size_t from, typename Xs, std::size_t ...i> - static constexpr auto from_offset(Xs&& xs, std::index_sequence<i...>) { - return hana::make<S>(hana::at_c<from + i>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename T, T from, T to> - static constexpr auto apply(Xs&& xs, hana::range<T, from, to> const&) { - return slice_impl::from_offset<from>( - static_cast<Xs&&>(xs), std::make_index_sequence<to - from>{} - ); - } - - //! @todo - //! Since we have the right to specify the same index more than once, - //! we can't move from the elements of the source sequence even if it - //! is a temporary object: we could end up double-moving. Perhaps it - //! would be possible to determine the indices from which we can move - //! without incurring a too large compile-time penalty? - template <typename Xs, typename Indices> - static constexpr auto apply(Xs const& xs, Indices const& indices) { - return hana::unpack(indices, detail::take_arbitrary<Xs const>{xs}); - } - }; - - template <std::size_t from, std::size_t to> - struct slice_c_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const { - return hana::slice(static_cast<Xs&&>(xs), - hana::range_c<std::size_t, from, to>); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SLICE_HPP diff --git a/contrib/restricted/boost/boost/hana/sort.hpp b/contrib/restricted/boost/boost/hana/sort.hpp deleted file mode 100644 index 65d6d27da3..0000000000 --- a/contrib/restricted/boost/boost/hana/sort.hpp +++ /dev/null @@ -1,173 +0,0 @@ -/*! -@file -Defines `boost::hana::sort`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SORT_HPP -#define BOOST_HANA_SORT_HPP - -#include <boost/hana/fwd/sort.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/length.hpp> -#include <boost/hana/less.hpp> - -#include <utility> // std::declval, std::index_sequence - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Predicate> - constexpr auto sort_t::operator()(Xs&& xs, Predicate&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Sort = BOOST_HANA_DISPATCH_IF(sort_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::sort(xs, predicate) requires 'xs' to be a Sequence"); - #endif - - return Sort::apply(static_cast<Xs&&>(xs), - static_cast<Predicate&&>(pred)); - } - - template <typename Xs> - constexpr auto sort_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Sort = BOOST_HANA_DISPATCH_IF(sort_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::sort(xs) requires 'xs' to be a Sequence"); - #endif - - return Sort::apply(static_cast<Xs&&>(xs)); - } - //! @endcond - - namespace detail { - template <typename Xs, typename Pred> - struct sort_predicate { - template <std::size_t I, std::size_t J> - using apply = decltype(std::declval<Pred>()( - hana::at_c<I>(std::declval<Xs>()), - hana::at_c<J>(std::declval<Xs>()) - )); - }; - - template <typename Pred, std::size_t Insert, bool IsInsertionPoint, - typename Left, - std::size_t ...Right> - struct insert; - - // We did not find the insertion point; continue processing elements - // recursively. - template < - typename Pred, std::size_t Insert, - std::size_t ...Left, - std::size_t Right1, std::size_t Right2, std::size_t ...Right - > - struct insert<Pred, Insert, false, - std::index_sequence<Left...>, - Right1, Right2, Right... - > { - using type = typename insert< - Pred, Insert, (bool)Pred::template apply<Insert, Right2>::value, - std::index_sequence<Left..., Right1>, - Right2, Right... - >::type; - }; - - // We did not find the insertion point, but there is only one element - // left. We insert at the end of the list, and we're done. - template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t Last> - struct insert<Pred, Insert, false, std::index_sequence<Left...>, Last> { - using type = std::index_sequence<Left..., Last, Insert>; - }; - - // We found the insertion point, we're done. - template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t ...Right> - struct insert<Pred, Insert, true, std::index_sequence<Left...>, Right...> { - using type = std::index_sequence<Left..., Insert, Right...>; - }; - - - template <typename Pred, typename Result, std::size_t ...T> - struct insertion_sort_impl; - - template <typename Pred, - std::size_t Result1, std::size_t ...Result, - std::size_t T, std::size_t ...Ts> - struct insertion_sort_impl<Pred, std::index_sequence<Result1, Result...>, T, Ts...> { - using type = typename insertion_sort_impl< - Pred, - typename insert< - Pred, T, (bool)Pred::template apply<T, Result1>::value, - std::index_sequence<>, - Result1, Result... - >::type, - Ts... - >::type; - }; - - template <typename Pred, std::size_t T, std::size_t ...Ts> - struct insertion_sort_impl<Pred, std::index_sequence<>, T, Ts...> { - using type = typename insertion_sort_impl< - Pred, std::index_sequence<T>, Ts... - >::type; - }; - - template <typename Pred, typename Result> - struct insertion_sort_impl<Pred, Result> { - using type = Result; - }; - - template <typename Pred, typename Indices> - struct sort_helper; - - template <typename Pred, std::size_t ...i> - struct sort_helper<Pred, std::index_sequence<i...>> { - using type = typename insertion_sort_impl< - Pred, std::index_sequence<>, i... - >::type; - }; - } // end namespace detail - - template <typename S, bool condition> - struct sort_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...i> - static constexpr auto apply_impl(Xs&& xs, std::index_sequence<i...>) { - return hana::make<S>(hana::at_c<i>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred const&) { - constexpr std::size_t Len = decltype(hana::length(xs))::value; - using Indices = typename detail::sort_helper< - detail::sort_predicate<Xs&&, Pred>, - std::make_index_sequence<Len> - >::type; - - return apply_impl(static_cast<Xs&&>(xs), Indices{}); - } - - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return sort_impl::apply(static_cast<Xs&&>(xs), hana::less); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SORT_HPP diff --git a/contrib/restricted/boost/boost/hana/span.hpp b/contrib/restricted/boost/boost/hana/span.hpp deleted file mode 100644 index 2219749b05..0000000000 --- a/contrib/restricted/boost/boost/hana/span.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::span`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SPAN_HPP -#define BOOST_HANA_SPAN_HPP - -#include <boost/hana/fwd/span.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/detail/first_unsatisfied_index.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/pair.hpp> -#include <boost/hana/unpack.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto span_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using Span = BOOST_HANA_DISPATCH_IF(span_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::span(xs, pred) requires 'xs' to be a Sequence"); - #endif - - return Span::apply(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct span_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...before, std::size_t ...after> - static constexpr auto span_helper(Xs&& xs, std::index_sequence<before...>, - std::index_sequence<after...>) - { - return hana::make_pair( - hana::make<S>(hana::at_c<before>(static_cast<Xs&&>(xs))...), - hana::make<S>(hana::at_c<sizeof...(before) + after>(static_cast<Xs&&>(xs))...) - ); - } - - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&&) { - using FirstUnsatisfied = decltype( - hana::unpack(static_cast<Xs&&>(xs), - detail::first_unsatisfied_index<Pred&&>{}) - ); - constexpr std::size_t breakpoint = FirstUnsatisfied::value; - constexpr std::size_t N = decltype(hana::length(xs))::value; - return span_helper(static_cast<Xs&&>(xs), - std::make_index_sequence<breakpoint>{}, - std::make_index_sequence<N - breakpoint>{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SPAN_HPP diff --git a/contrib/restricted/boost/boost/hana/string.hpp b/contrib/restricted/boost/boost/hana/string.hpp deleted file mode 100644 index a7b83dee86..0000000000 --- a/contrib/restricted/boost/boost/hana/string.hpp +++ /dev/null @@ -1,349 +0,0 @@ -/*! -@file -Defines `boost::hana::string`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_STRING_HPP -#define BOOST_HANA_STRING_HPP - -#include <boost/hana/fwd/string.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/iterable.hpp> -#include <boost/hana/detail/operators/orderable.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/contains.hpp> -#include <boost/hana/fwd/core/tag_of.hpp> -#include <boost/hana/fwd/core/to.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/find.hpp> -#include <boost/hana/fwd/front.hpp> -#include <boost/hana/fwd/hash.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/less.hpp> -#include <boost/hana/fwd/plus.hpp> -#include <boost/hana/fwd/unpack.hpp> -#include <boost/hana/fwd/zero.hpp> -#include <boost/hana/if.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/type.hpp> - -#include <utility> -#include <cstddef> -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // string<> - ////////////////////////////////////////////////////////////////////////// - //! @cond - namespace detail { - template <char ...s> - constexpr char const string_storage[sizeof...(s) + 1] = {s..., '\0'}; - } - - template <char ...s> - struct string - : detail::operators::adl<string<s...>> - , detail::iterable_operators<string<s...>> - { - static constexpr char const* c_str() { - return &detail::string_storage<s...>[0]; - } - }; - //! @endcond - - template <char ...s> - struct tag_of<string<s...>> { - using type = string_tag; - }; - - ////////////////////////////////////////////////////////////////////////// - // make<string_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<string_tag> { - template <typename ...Chars> - static constexpr auto apply(Chars const& ...) { - return hana::string<hana::value<Chars>()...>{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // BOOST_HANA_STRING - ////////////////////////////////////////////////////////////////////////// - namespace string_detail { - template <typename S, std::size_t ...N> - constexpr string<S::get()[N]...> - prepare_impl(S, std::index_sequence<N...>) - { return {}; } - - template <typename S> - constexpr decltype(auto) prepare(S s) { - return prepare_impl(s, - std::make_index_sequence<sizeof(S::get()) - 1>{}); - } - } - -#define BOOST_HANA_STRING(s) \ - (::boost::hana::string_detail::prepare([]{ \ - struct tmp { \ - static constexpr decltype(auto) get() { return s; } \ - }; \ - return tmp{}; \ - }())) \ -/**/ - -#ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL - ////////////////////////////////////////////////////////////////////////// - // _s user-defined literal - ////////////////////////////////////////////////////////////////////////// - namespace literals { - template <typename CharT, CharT ...s> - constexpr auto operator"" _s() { - static_assert(std::is_same<CharT, char>::value, - "hana::string: Only narrow string literals are supported with " - "the _s string literal right now. See https://goo.gl/fBbKD7 " - "if you need support for fancier types of compile-time strings."); - return hana::string_c<s...>; - } - } -#endif - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<string_tag> { - static constexpr bool value = true; - }; - template <> - struct orderable_operators<string_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // to<char const*> - ////////////////////////////////////////////////////////////////////////// - template <> - struct to_impl<char const*, string_tag> { - template <char ...c> - static constexpr char const* apply(string<c...> const&) - { return string<c...>::c_str(); } - }; - - ////////////////////////////////////////////////////////////////////////// - // to<string_tag> - ////////////////////////////////////////////////////////////////////////// - namespace detail { - constexpr std::size_t cx_strlen(char const* s) { - std::size_t n = 0u; - while (*s != '\0') - ++s, ++n; - return n; - } - - template <typename S, std::size_t ...I> - constexpr hana::string<hana::value<S>()[I]...> expand(std::index_sequence<I...>) - { return {}; } - } - - template <typename IC> - struct to_impl<hana::string_tag, IC, hana::when< - hana::Constant<IC>::value && - std::is_convertible<typename IC::value_type, char const*>::value - >> { - template <typename S> - static constexpr auto apply(S const&) { - constexpr char const* s = hana::value<S>(); - constexpr std::size_t len = detail::cx_strlen(s); - return detail::expand<S>(std::make_index_sequence<len>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<string_tag, string_tag> { - template <typename S> - static constexpr auto apply(S const&, S const&) - { return hana::true_c; } - - template <typename S1, typename S2> - static constexpr auto apply(S1 const&, S2 const&) - { return hana::false_c; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Orderable - ////////////////////////////////////////////////////////////////////////// - template <> - struct less_impl<string_tag, string_tag> { - template <char ...s1, char ...s2> - static constexpr auto - apply(string<s1...> const&, string<s2...> const&) { - // We put a '\0' at the end only to avoid empty arrays. - constexpr char const c_str1[] = {s1..., '\0'}; - constexpr char const c_str2[] = {s2..., '\0'}; - return hana::bool_c<detail::lexicographical_compare( - c_str1, c_str1 + sizeof...(s1), - c_str2, c_str2 + sizeof...(s2) - )>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Monoid - ////////////////////////////////////////////////////////////////////////// - template <> - struct plus_impl<string_tag, string_tag> { - template <char ...s1, char ...s2> - static constexpr auto - apply(string<s1...> const&, string<s2...> const&) { - return string<s1..., s2...>{}; - } - }; - - template <> - struct zero_impl<string_tag> { - static constexpr auto apply() { - return string<>{}; - } - }; - - template <char ...s1, char ...s2> - constexpr auto operator+(string<s1...> const&, string<s2...> const&) { - return hana::string<s1..., s2...>{}; - } - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<string_tag> { - template <char ...s, typename F> - static constexpr decltype(auto) apply(string<s...> const&, F&& f) - { return static_cast<F&&>(f)(char_<s>{}...); } - }; - - template <> - struct length_impl<string_tag> { - template <char ...s> - static constexpr auto apply(string<s...> const&) - { return hana::size_c<sizeof...(s)>; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct front_impl<string_tag> { - template <char x, char ...xs> - static constexpr auto apply(string<x, xs...> const&) - { return hana::char_c<x>; } - }; - - template <> - struct drop_front_impl<string_tag> { - template <std::size_t N, char ...xs, std::size_t ...i> - static constexpr auto helper(string<xs...> const&, std::index_sequence<i...>) { - constexpr char s[] = {xs...}; - return hana::string_c<s[i + N]...>; - } - - template <char ...xs, typename N> - static constexpr auto apply(string<xs...> const& s, N const&) { - return helper<N::value>(s, std::make_index_sequence< - N::value < sizeof...(xs) ? sizeof...(xs) - N::value : 0 - >{}); - } - - template <typename N> - static constexpr auto apply(string<> const& s, N const&) - { return s; } - }; - - template <> - struct is_empty_impl<string_tag> { - template <char ...s> - static constexpr auto apply(string<s...> const&) - { return hana::bool_c<sizeof...(s) == 0>; } - }; - - template <> - struct at_impl<string_tag> { - template <char ...s, typename N> - static constexpr auto apply(string<s...> const&, N const&) { - // We put a '\0' at the end to avoid an empty array. - constexpr char characters[] = {s..., '\0'}; - constexpr auto n = N::value; - return hana::char_c<characters[n]>; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Searchable - ////////////////////////////////////////////////////////////////////////// - template <> - struct contains_impl<string_tag> { - template <char ...s, typename C> - static constexpr auto - helper(string<s...> const&, C const&, hana::true_) { - constexpr char const characters[] = {s..., '\0'}; - constexpr char c = hana::value<C>(); - return hana::bool_c< - detail::find(characters, characters + sizeof...(s), c) - != characters + sizeof...(s) - >; - } - - template <typename S, typename C> - static constexpr auto helper(S const&, C const&, hana::false_) - { return hana::false_c; } - - template <typename S, typename C> - static constexpr auto apply(S const& s, C const& c) - { return helper(s, c, hana::bool_c<hana::Constant<C>::value>); } - }; - - template <> - struct find_impl<string_tag> { - template <char ...s, typename Char> - static constexpr auto apply(string<s...> const& str, Char const& c) { - return hana::if_(contains_impl<string_tag>::apply(str, c), - hana::just(c), - hana::nothing - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Hashable - ////////////////////////////////////////////////////////////////////////// - template <> - struct hash_impl<string_tag> { - template <typename String> - static constexpr auto apply(String const&) { - return hana::type_c<String>; - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_STRING_HPP diff --git a/contrib/restricted/boost/boost/hana/suffix.hpp b/contrib/restricted/boost/boost/hana/suffix.hpp deleted file mode 100644 index 68a344db6e..0000000000 --- a/contrib/restricted/boost/boost/hana/suffix.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/*! -@file -Defines `boost::hana::suffix`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SUFFIX_HPP -#define BOOST_HANA_SUFFIX_HPP - -#include <boost/hana/fwd/suffix.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/monad_plus.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/lift.hpp> -#include <boost/hana/prepend.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Sfx> - constexpr auto suffix_t::operator()(Xs&& xs, Sfx&& sfx) const { - using M = typename hana::tag_of<Xs>::type; - using Suffix = BOOST_HANA_DISPATCH_IF(suffix_impl<M>, - hana::MonadPlus<M>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::MonadPlus<M>::value, - "hana::suffix(xs, sfx) requires 'xs' to be a MonadPlus"); - #endif - - return Suffix::apply(static_cast<Xs&&>(xs), static_cast<Sfx&&>(sfx)); - } - //! @endcond - - template <typename M, bool condition> - struct suffix_impl<M, when<condition>> : default_ { - template <typename Xs, typename Z> - static constexpr auto apply(Xs&& xs, Z&& z) { - return hana::chain(static_cast<Xs&&>(xs), - hana::partial(hana::prepend, hana::lift<M>(static_cast<Z&&>(z)))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SUFFIX_HPP diff --git a/contrib/restricted/boost/boost/hana/sum.hpp b/contrib/restricted/boost/boost/hana/sum.hpp deleted file mode 100644 index 5c86dafdde..0000000000 --- a/contrib/restricted/boost/boost/hana/sum.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*! -@file -Defines `boost::hana::sum`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SUM_HPP -#define BOOST_HANA_SUM_HPP - -#include <boost/hana/fwd/sum.hpp> - -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/monoid.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/fold_left.hpp> -#include <boost/hana/integral_constant.hpp> // required by fwd decl -#include <boost/hana/plus.hpp> -#include <boost/hana/zero.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct sum_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monoid<M>::value, - "hana::sum<M> requires 'M' to be a Monoid"); - #endif - - template <typename Xs> - constexpr decltype(auto) operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Sum = BOOST_HANA_DISPATCH_IF(sum_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::sum<M>(xs) requires 'xs' to be Foldable"); - #endif - - return Sum::template apply<M>(static_cast<Xs&&>(xs)); - } - }; - - template <typename T, bool condition> - struct sum_impl<T, when<condition>> : default_ { - template <typename M, typename Xs> - static constexpr decltype(auto) apply(Xs&& xs) { - return hana::fold_left(static_cast<Xs&&>(xs), hana::zero<M>(), hana::plus); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SUM_HPP diff --git a/contrib/restricted/boost/boost/hana/symmetric_difference.hpp b/contrib/restricted/boost/boost/hana/symmetric_difference.hpp deleted file mode 100644 index 1ca56d3019..0000000000 --- a/contrib/restricted/boost/boost/hana/symmetric_difference.hpp +++ /dev/null @@ -1,46 +0,0 @@ -/*! -@file -Defines `boost::hana::symmetric_difference`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP -#define BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP - -#include <boost/hana/fwd/symmetric_difference.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/difference.hpp> -#include <boost/hana/union.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto symmetric_difference_t::operator()(Xs&& xs, Ys&& ys) const { - using S = typename hana::tag_of<Xs>::type; - using SymmetricDifference = BOOST_HANA_DISPATCH_IF(symmetric_difference_impl<S>, - true - ); - - return SymmetricDifference::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename S, bool condition> - struct symmetric_difference_impl<S, when<condition>> : default_ { - template <typename Xs, typename Ys> - static constexpr auto apply(Xs&& xs, Ys&& ys) { - return hana::union_( - hana::difference(xs, ys), - hana::difference(ys, xs) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_SYMMETRIC_DIFFERENCE_HPP diff --git a/contrib/restricted/boost/boost/hana/take_back.hpp b/contrib/restricted/boost/boost/hana/take_back.hpp deleted file mode 100644 index 4d9c39974f..0000000000 --- a/contrib/restricted/boost/boost/hana/take_back.hpp +++ /dev/null @@ -1,76 +0,0 @@ -/*! -@file -Defines `boost::hana::take_back`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TAKE_BACK_HPP -#define BOOST_HANA_TAKE_BACK_HPP - -#include <boost/hana/fwd/take_back.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto take_back_t::operator()(Xs&& xs, N const& n) const { - using S = typename hana::tag_of<Xs>::type; - using TakeBack = BOOST_HANA_DISPATCH_IF(take_back_impl<S>, - hana::Sequence<S>::value && - hana::IntegralConstant<N>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::take_back(xs, n) requires 'xs' to be a Sequence"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::take_back(xs, n) requires 'n' to be an IntegralConstant"); -#endif - - return TakeBack::apply(static_cast<Xs&&>(xs), n); - } - //! @endcond - - template <typename S, bool condition> - struct take_back_impl<S, when<condition>> : default_ { - template <std::size_t start, typename Xs, std::size_t ...n> - static constexpr auto take_back_helper(Xs&& xs, std::index_sequence<n...>) { - return hana::make<S>(hana::at_c<start + n>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t len = decltype(hana::length(xs))::value; - constexpr std::size_t start = n < len ? len - n : 0; - return take_back_helper<start>(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < len ? n : len)>{}); - } - }; - - template <std::size_t n> - struct take_back_c_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const { - return hana::take_back(static_cast<Xs&&>(xs), hana::size_c<n>); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TAKE_BACK_HPP diff --git a/contrib/restricted/boost/boost/hana/take_front.hpp b/contrib/restricted/boost/boost/hana/take_front.hpp deleted file mode 100644 index b32fbb6e50..0000000000 --- a/contrib/restricted/boost/boost/hana/take_front.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::take_front` and `boost::hana::take_front_c`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TAKE_FRONT_HPP -#define BOOST_HANA_TAKE_FRONT_HPP - -#include <boost/hana/fwd/take_front.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename N> - constexpr auto take_front_t::operator()(Xs&& xs, N const& n) const { - using S = typename hana::tag_of<Xs>::type; - using TakeFront = BOOST_HANA_DISPATCH_IF(take_front_impl<S>, - hana::Sequence<S>::value && - hana::IntegralConstant<N>::value - ); - -#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::take_front(xs, n) requires 'xs' to be a Sequence"); - - static_assert(hana::IntegralConstant<N>::value, - "hana::take_front(xs, n) requires 'n' to be an IntegralConstant"); -#endif - - return TakeFront::apply(static_cast<Xs&&>(xs), n); - } - //! @endcond - - template <typename S, bool condition> - struct take_front_impl<S, when<condition>> : default_ { - template <typename Xs, std::size_t ...n> - static constexpr auto take_front_helper(Xs&& xs, std::index_sequence<n...>) { - return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t n = N::value; - constexpr std::size_t size = decltype(hana::length(xs))::value; - return take_front_helper(static_cast<Xs&&>(xs), - std::make_index_sequence<(n < size ? n : size)>{}); - } - }; - - template <std::size_t n> - struct take_front_c_t { - template <typename Xs> - constexpr auto operator()(Xs&& xs) const { - return hana::take_front(static_cast<Xs&&>(xs), hana::size_c<n>); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TAKE_FRONT_HPP diff --git a/contrib/restricted/boost/boost/hana/take_while.hpp b/contrib/restricted/boost/boost/hana/take_while.hpp deleted file mode 100644 index 392459dca7..0000000000 --- a/contrib/restricted/boost/boost/hana/take_while.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Defines `boost::hana::take_while`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TAKE_WHILE_HPP -#define BOOST_HANA_TAKE_WHILE_HPP - -#include <boost/hana/fwd/take_while.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/first_unsatisfied_index.hpp> -#include <boost/hana/take_front.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Pred> - constexpr auto take_while_t::operator()(Xs&& xs, Pred&& pred) const { - using S = typename hana::tag_of<Xs>::type; - using TakeWhile = BOOST_HANA_DISPATCH_IF(take_while_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::take_while(xs, pred) requires 'xs' to be a Sequence"); - #endif - - return TakeWhile::apply(static_cast<Xs&&>(xs), - static_cast<Pred&&>(pred)); - } - //! @endcond - - template <typename S, bool condition> - struct take_while_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&&) { - using FirstUnsatisfied = decltype( - hana::unpack(static_cast<Xs&&>(xs), - detail::first_unsatisfied_index<Pred&&>{}) - ); - return hana::take_front(static_cast<Xs&&>(xs), FirstUnsatisfied{}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TAKE_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/tap.hpp b/contrib/restricted/boost/boost/hana/tap.hpp deleted file mode 100644 index 7d37318255..0000000000 --- a/contrib/restricted/boost/boost/hana/tap.hpp +++ /dev/null @@ -1,59 +0,0 @@ -/*! -@file -Defines `boost::hana::tap`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TAP_HPP -#define BOOST_HANA_TAP_HPP - -#include <boost/hana/fwd/tap.hpp> - -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/lift.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct tap_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::tap<M> requires 'M' to be a Monad"); - #endif - - template <typename F> - constexpr auto operator()(F&& f) const { - using Tap = BOOST_HANA_DISPATCH_IF(tap_impl<M>, - hana::Monad<M>::value - ); - - return Tap::apply(static_cast<F&&>(f)); - } - }; - - namespace detail { - template <typename M> - struct tap_helper { - template <typename F, typename X> - constexpr auto operator()(F&& f, X&& x) const { - (void)static_cast<F&&>(f)(x); - return hana::lift<M>(static_cast<X&&>(x)); - } - }; - } - - template <typename M, bool condition> - struct tap_impl<M, when<condition>> : default_ { - template <typename F> - static constexpr auto apply(F&& f) - { return hana::partial(detail::tap_helper<M>{}, static_cast<F&&>(f)); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TAP_HPP diff --git a/contrib/restricted/boost/boost/hana/then.hpp b/contrib/restricted/boost/boost/hana/then.hpp deleted file mode 100644 index b6d74cfcf4..0000000000 --- a/contrib/restricted/boost/boost/hana/then.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*! -@file -Defines `boost::hana::then`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_THEN_HPP -#define BOOST_HANA_THEN_HPP - -#include <boost/hana/fwd/then.hpp> - -#include <boost/hana/chain.hpp> -#include <boost/hana/concept/monad.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/functional/always.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Before, typename Xs> - constexpr decltype(auto) then_t::operator()(Before&& before, Xs&& xs) const { - using M = typename hana::tag_of<Before>::type; - using Then = BOOST_HANA_DISPATCH_IF(then_impl<M>, - hana::Monad<M>::value && - hana::Monad<Xs>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monad<M>::value, - "hana::then(before, xs) requires 'before' to be a Monad"); - - static_assert(hana::Monad<Xs>::value, - "hana::then(before, xs) requires 'xs' to be a Monad"); - #endif - - return Then::apply(static_cast<Before&&>(before), - static_cast<Xs&&>(xs)); - } - //! @endcond - - template <typename M, bool condition> - struct then_impl<M, when<condition>> : default_ { - template <typename Xs, typename Ys> - static constexpr decltype(auto) apply(Xs&& xs, Ys&& ys) { - return hana::chain(static_cast<Xs&&>(xs), - hana::always(static_cast<Ys&&>(ys))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_THEN_HPP diff --git a/contrib/restricted/boost/boost/hana/traits.hpp b/contrib/restricted/boost/boost/hana/traits.hpp deleted file mode 100644 index 983bdf8367..0000000000 --- a/contrib/restricted/boost/boost/hana/traits.hpp +++ /dev/null @@ -1,213 +0,0 @@ -/*! -@file -Defines function-like equivalents to the standard `<type_traits>`, and also -to some utilities like `std::declval`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TRAITS_HPP -#define BOOST_HANA_TRAITS_HPP - -#include <boost/hana/config.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/type.hpp> - -#include <cstddef> -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN namespace traits { - namespace detail { - // We use this instead of hana::integral because we want to return - // hana::integral_constants instead of std::integral_constants. - template <template <typename ...> class F> - struct hana_trait { - template <typename ...T> - constexpr auto operator()(T const& ...) const { - using Result = typename F<typename T::type...>::type; - return hana::integral_c<typename Result::value_type, Result::value>; - } - }; - } - - /////////////////////// - // Type properties - /////////////////////// - // Primary type categories - constexpr auto is_void = detail::hana_trait<std::is_void>{}; - constexpr auto is_null_pointer = detail::hana_trait<std::is_null_pointer>{}; - constexpr auto is_integral = detail::hana_trait<std::is_integral>{}; - constexpr auto is_floating_point = detail::hana_trait<std::is_floating_point>{}; - constexpr auto is_array = detail::hana_trait<std::is_array>{}; - constexpr auto is_enum = detail::hana_trait<std::is_enum>{}; - constexpr auto is_union = detail::hana_trait<std::is_union>{}; - constexpr auto is_class = detail::hana_trait<std::is_class>{}; - constexpr auto is_function = detail::hana_trait<std::is_function>{}; - constexpr auto is_pointer = detail::hana_trait<std::is_pointer>{}; - constexpr auto is_lvalue_reference = detail::hana_trait<std::is_lvalue_reference>{}; - constexpr auto is_rvalue_reference = detail::hana_trait<std::is_rvalue_reference>{}; - constexpr auto is_member_object_pointer = detail::hana_trait<std::is_member_object_pointer>{}; - constexpr auto is_member_function_pointer = detail::hana_trait<std::is_member_function_pointer>{}; - - // Composite type categories - constexpr auto is_fundamental = detail::hana_trait<std::is_fundamental>{}; - constexpr auto is_arithmetic = detail::hana_trait<std::is_arithmetic>{}; - constexpr auto is_scalar = detail::hana_trait<std::is_scalar>{}; - constexpr auto is_object = detail::hana_trait<std::is_object>{}; - constexpr auto is_compound = detail::hana_trait<std::is_compound>{}; - constexpr auto is_reference = detail::hana_trait<std::is_reference>{}; - constexpr auto is_member_pointer = detail::hana_trait<std::is_member_pointer>{}; - - // Type properties - constexpr auto is_const = detail::hana_trait<std::is_const>{}; - constexpr auto is_volatile = detail::hana_trait<std::is_volatile>{}; - constexpr auto is_trivial = detail::hana_trait<std::is_trivial>{}; - constexpr auto is_trivially_copyable = detail::hana_trait<std::is_trivially_copyable>{}; - constexpr auto is_standard_layout = detail::hana_trait<std::is_standard_layout>{}; - constexpr auto is_pod = detail::hana_trait<std::is_pod>{}; - constexpr auto is_literal_type = detail::hana_trait<std::is_literal_type>{}; - constexpr auto is_empty = detail::hana_trait<std::is_empty>{}; - constexpr auto is_polymorphic = detail::hana_trait<std::is_polymorphic>{}; - constexpr auto is_abstract = detail::hana_trait<std::is_abstract>{}; - constexpr auto is_signed = detail::hana_trait<std::is_signed>{}; - constexpr auto is_unsigned = detail::hana_trait<std::is_unsigned>{}; - - // Supported operations - constexpr auto is_constructible = detail::hana_trait<std::is_constructible>{}; - constexpr auto is_trivially_constructible = detail::hana_trait<std::is_trivially_constructible>{}; - constexpr auto is_nothrow_constructible = detail::hana_trait<std::is_nothrow_constructible>{}; - - constexpr auto is_default_constructible = detail::hana_trait<std::is_default_constructible>{}; - constexpr auto is_trivially_default_constructible = detail::hana_trait<std::is_trivially_default_constructible>{}; - constexpr auto is_nothrow_default_constructible = detail::hana_trait<std::is_nothrow_default_constructible>{}; - - constexpr auto is_copy_constructible = detail::hana_trait<std::is_copy_constructible>{}; - constexpr auto is_trivially_copy_constructible = detail::hana_trait<std::is_trivially_copy_constructible>{}; - constexpr auto is_nothrow_copy_constructible = detail::hana_trait<std::is_nothrow_copy_constructible>{}; - - constexpr auto is_move_constructible = detail::hana_trait<std::is_move_constructible>{}; - constexpr auto is_trivially_move_constructible = detail::hana_trait<std::is_trivially_move_constructible>{}; - constexpr auto is_nothrow_move_constructible = detail::hana_trait<std::is_nothrow_move_constructible>{}; - - constexpr auto is_assignable = detail::hana_trait<std::is_assignable>{}; - constexpr auto is_trivially_assignable = detail::hana_trait<std::is_trivially_assignable>{}; - constexpr auto is_nothrow_assignable = detail::hana_trait<std::is_nothrow_assignable>{}; - - constexpr auto is_copy_assignable = detail::hana_trait<std::is_copy_assignable>{}; - constexpr auto is_trivially_copy_assignable = detail::hana_trait<std::is_trivially_copy_assignable>{}; - constexpr auto is_nothrow_copy_assignable = detail::hana_trait<std::is_nothrow_copy_assignable>{}; - - constexpr auto is_move_assignable = detail::hana_trait<std::is_move_assignable>{}; - constexpr auto is_trivially_move_assignable = detail::hana_trait<std::is_trivially_move_assignable>{}; - constexpr auto is_nothrow_move_assignable = detail::hana_trait<std::is_nothrow_move_assignable>{}; - - constexpr auto is_destructible = detail::hana_trait<std::is_destructible>{}; - constexpr auto is_trivially_destructible = detail::hana_trait<std::is_trivially_destructible>{}; - constexpr auto is_nothrow_destructible = detail::hana_trait<std::is_nothrow_destructible>{}; - - constexpr auto has_virtual_destructor = detail::hana_trait<std::has_virtual_destructor>{}; - - // Property queries - constexpr auto alignment_of = detail::hana_trait<std::alignment_of>{}; - constexpr auto rank = detail::hana_trait<std::rank>{}; - constexpr struct extent_t { - template <typename T, typename N> - constexpr auto operator()(T const&, N const&) const { - constexpr unsigned n = N::value; - using Result = typename std::extent<typename T::type, n>::type; - return hana::integral_c<typename Result::value_type, Result::value>; - } - - template <typename T> - constexpr auto operator()(T const& t) const - { return (*this)(t, hana::uint_c<0>); } - } extent{}; - - // Type relationships - constexpr auto is_same = detail::hana_trait<std::is_same>{}; - constexpr auto is_base_of = detail::hana_trait<std::is_base_of>{}; - constexpr auto is_convertible = detail::hana_trait<std::is_convertible>{}; - - /////////////////////// - // Type modifications - /////////////////////// - // Const-volatility specifiers - constexpr auto remove_cv = metafunction<std::remove_cv>; - constexpr auto remove_const = metafunction<std::remove_const>; - constexpr auto remove_volatile = metafunction<std::remove_volatile>; - - constexpr auto add_cv = metafunction<std::add_cv>; - constexpr auto add_const = metafunction<std::add_const>; - constexpr auto add_volatile = metafunction<std::add_volatile>; - - // References - constexpr auto remove_reference = metafunction<std::remove_reference>; - constexpr auto add_lvalue_reference = metafunction<std::add_lvalue_reference>; - constexpr auto add_rvalue_reference = metafunction<std::add_rvalue_reference>; - - // Pointers - constexpr auto remove_pointer = metafunction<std::remove_pointer>; - constexpr auto add_pointer = metafunction<std::add_pointer>; - - // Sign modifiers - constexpr auto make_signed = metafunction<std::make_signed>; - constexpr auto make_unsigned = metafunction<std::make_unsigned>; - - // Arrays - constexpr auto remove_extent = metafunction<std::remove_extent>; - constexpr auto remove_all_extents = metafunction<std::remove_all_extents>; - - // Miscellaneous transformations - constexpr struct aligned_storage_t { - template <typename Len, typename Align> - constexpr auto operator()(Len const&, Align const&) const { - constexpr std::size_t len = Len::value; - constexpr std::size_t align = Align::value; - using Result = typename std::aligned_storage<len, align>::type; - return hana::type_c<Result>; - } - - template <typename Len> - constexpr auto operator()(Len const&) const { - constexpr std::size_t len = Len::value; - using Result = typename std::aligned_storage<len>::type; - return hana::type_c<Result>; - } - } aligned_storage{}; - - constexpr struct aligned_union_t { - template <typename Len, typename ...T> - constexpr auto operator()(Len const&, T const&...) const { - constexpr std::size_t len = Len::value; - using Result = typename std::aligned_union<len, typename T::type...>::type; - return hana::type_c<Result>; - } - } aligned_union{}; - - constexpr auto decay = metafunction<std::decay>; - // enable_if - // disable_if - // conditional - - constexpr auto common_type = metafunction<std::common_type>; - constexpr auto underlying_type = metafunction<std::underlying_type>; - constexpr auto result_of = metafunction<std::result_of>; - - - /////////////////////// - // Utilities - /////////////////////// - struct declval_t { - template <typename T> - typename std::add_rvalue_reference< - typename T::type - >::type operator()(T const&) const; - }; - - constexpr declval_t declval{}; -} BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TRAITS_HPP diff --git a/contrib/restricted/boost/boost/hana/transform.hpp b/contrib/restricted/boost/boost/hana/transform.hpp deleted file mode 100644 index 7c68731e2d..0000000000 --- a/contrib/restricted/boost/boost/hana/transform.hpp +++ /dev/null @@ -1,76 +0,0 @@ -/*! -@file -Defines `boost::hana::transform`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TRANSFORM_HPP -#define BOOST_HANA_TRANSFORM_HPP - -#include <boost/hana/fwd/transform.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/functor.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/functional/always.hpp> -#include <boost/hana/fwd/adjust_if.hpp> -#include <boost/hana/unpack.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr auto transform_t::operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using Transform = BOOST_HANA_DISPATCH_IF(transform_impl<S>, - hana::Functor<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Functor<S>::value, - "hana::transform(xs, f) requires 'xs' to be a Functor"); - #endif - - return Transform::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - template <typename Fun, bool condition> - struct transform_impl<Fun, when<condition>> : default_ { - template <typename Xs, typename F> - static constexpr auto apply(Xs&& xs, F&& f) { - return hana::adjust_if(static_cast<Xs&&>(xs), - hana::always(hana::true_c), - static_cast<F&&>(f)); - } - }; - - template <typename S> - struct transform_impl<S, when<Sequence<S>::value>> { - //! @cond - template <typename F> - struct transformer { - F f; - template <typename ...Xs> - constexpr auto operator()(Xs&& ...xs) const { - return hana::make<S>((*f)(static_cast<Xs&&>(xs))...); - } - }; - //! @endcond - - template <typename Xs, typename F> - static constexpr auto apply(Xs&& xs, F&& f) { - // We use a pointer to workaround a Clang 3.5 ICE - return hana::unpack(static_cast<Xs&&>(xs), - transformer<decltype(&f)>{&f}); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TRANSFORM_HPP diff --git a/contrib/restricted/boost/boost/hana/tuple.hpp b/contrib/restricted/boost/boost/hana/tuple.hpp deleted file mode 100644 index 3354a84bee..0000000000 --- a/contrib/restricted/boost/boost/hana/tuple.hpp +++ /dev/null @@ -1,312 +0,0 @@ -/*! -@file -Defines `boost::hana::tuple`. - -@copyright Louis Dionne 2013-2017 -@copyright Jason Rice 2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TUPLE_HPP -#define BOOST_HANA_TUPLE_HPP - -#include <boost/hana/fwd/tuple.hpp> - -#include <boost/hana/basic_tuple.hpp> -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/decay.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/detail/index_if.hpp> -#include <boost/hana/detail/intrinsics.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/detail/operators/iterable.hpp> -#include <boost/hana/detail/operators/monad.hpp> -#include <boost/hana/detail/operators/orderable.hpp> -#include <boost/hana/fwd/at.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/drop_front.hpp> -#include <boost/hana/fwd/index_if.hpp> -#include <boost/hana/fwd/is_empty.hpp> -#include <boost/hana/fwd/length.hpp> -#include <boost/hana/fwd/optional.hpp> -#include <boost/hana/fwd/unpack.hpp> -#include <boost/hana/type.hpp> // required by fwd decl of tuple_t - -#include <cstddef> -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - namespace detail { - template <typename Xs, typename Ys, std::size_t ...n> - constexpr void assign(Xs& xs, Ys&& ys, std::index_sequence<n...>) { - int sequence[] = {int{}, ((void)( - hana::at_c<n>(xs) = hana::at_c<n>(static_cast<Ys&&>(ys)) - ), int{})...}; - (void)sequence; - } - - struct from_index_sequence_t { }; - - template <typename Tuple, typename ...Yn> - struct is_same_tuple : std::false_type { }; - - template <typename Tuple> - struct is_same_tuple<typename detail::decay<Tuple>::type, Tuple> - : std::true_type - { }; - - template <bool SameTuple, bool SameNumberOfElements, typename Tuple, typename ...Yn> - struct enable_tuple_variadic_ctor; - - template <typename ...Xn, typename ...Yn> - struct enable_tuple_variadic_ctor<false, true, hana::tuple<Xn...>, Yn...> - : std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value - > - { }; - } - - ////////////////////////////////////////////////////////////////////////// - // tuple - ////////////////////////////////////////////////////////////////////////// - template <> - struct tuple<> - : detail::operators::adl<tuple<>> - , detail::iterable_operators<tuple<>> - { - constexpr tuple() { } - using hana_tag = tuple_tag; - }; - - template <typename ...Xn> - struct tuple - : detail::operators::adl<tuple<Xn...>> - , detail::iterable_operators<tuple<Xn...>> - { - basic_tuple<Xn...> storage_; - using hana_tag = tuple_tag; - - private: - template <typename Other, std::size_t ...n> - explicit constexpr tuple(detail::from_index_sequence_t, std::index_sequence<n...>, Other&& other) - : storage_(hana::at_c<n>(static_cast<Other&&>(other))...) - { } - - public: - template <typename ...dummy, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, dummy...)...>::value - >::type> - constexpr tuple() - : storage_() - { } - - template <typename ...dummy, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value - >::type> - constexpr tuple(Xn const& ...xn) - : storage_(xn...) - { } - - template <typename ...Yn, typename = typename detail::enable_tuple_variadic_ctor< - detail::is_same_tuple<tuple, Yn...>::value, - sizeof...(Xn) == sizeof...(Yn), tuple, Yn... - >::type> - constexpr tuple(Yn&& ...yn) - : storage_(static_cast<Yn&&>(yn)...) - { } - - template <typename ...Yn, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn const&)...>::value - >::type> - constexpr tuple(tuple<Yn...> const& other) - : tuple(detail::from_index_sequence_t{}, - std::make_index_sequence<sizeof...(Xn)>{}, - other.storage_) - { } - - template <typename ...Yn, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Yn&&)...>::value - >::type> - constexpr tuple(tuple<Yn...>&& other) - : tuple(detail::from_index_sequence_t{}, - std::make_index_sequence<sizeof...(Xn)>{}, - static_cast<tuple<Yn...>&&>(other).storage_) - { } - - // The three following constructors are required to make sure that - // the tuple(Yn&&...) constructor is _not_ preferred over the copy - // constructor for unary tuples containing a type that is constructible - // from tuple<...>. See test/tuple/cnstr.trap.cpp - template <typename ...dummy, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value - >::type> - constexpr tuple(tuple const& other) - : tuple(detail::from_index_sequence_t{}, - std::make_index_sequence<sizeof...(Xn)>{}, - other.storage_) - { } - - template <typename ...dummy, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn const&, dummy...)...>::value - >::type> - constexpr tuple(tuple& other) - : tuple(const_cast<tuple const&>(other)) - { } - - template <typename ...dummy, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_CONSTRUCTIBLE(Xn, Xn&&, dummy...)...>::value - >::type> - constexpr tuple(tuple&& other) - : tuple(detail::from_index_sequence_t{}, - std::make_index_sequence<sizeof...(Xn)>{}, - static_cast<tuple&&>(other).storage_) - { } - - - template <typename ...Yn, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn const&)...>::value - >::type> - constexpr tuple& operator=(tuple<Yn...> const& other) { - detail::assign(this->storage_, other.storage_, - std::make_index_sequence<sizeof...(Xn)>{}); - return *this; - } - - template <typename ...Yn, typename = typename std::enable_if< - detail::fast_and<BOOST_HANA_TT_IS_ASSIGNABLE(Xn&, Yn&&)...>::value - >::type> - constexpr tuple& operator=(tuple<Yn...>&& other) { - detail::assign(this->storage_, static_cast<tuple<Yn...>&&>(other).storage_, - std::make_index_sequence<sizeof...(Xn)>{}); - return *this; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<tuple_tag> { - static constexpr bool value = true; - }; - template <> - struct orderable_operators<tuple_tag> { - static constexpr bool value = true; - }; - template <> - struct monad_operators<tuple_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Foldable - ////////////////////////////////////////////////////////////////////////// - template <> - struct unpack_impl<tuple_tag> { - template <typename F> - static constexpr decltype(auto) apply(tuple<>&&, F&& f) - { return static_cast<F&&>(f)(); } - template <typename F> - static constexpr decltype(auto) apply(tuple<>&, F&& f) - { return static_cast<F&&>(f)(); } - template <typename F> - static constexpr decltype(auto) apply(tuple<> const&, F&& f) - { return static_cast<F&&>(f)(); } - - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - return hana::unpack(static_cast<Xs&&>(xs).storage_, static_cast<F&&>(f)); - } - }; - - template <> - struct length_impl<tuple_tag> { - template <typename ...Xs> - static constexpr auto apply(tuple<Xs...> const&) - { return hana::size_c<sizeof...(Xs)>; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Iterable - ////////////////////////////////////////////////////////////////////////// - template <> - struct at_impl<tuple_tag> { - template <typename Xs, typename N> - static constexpr decltype(auto) apply(Xs&& xs, N const&) { - constexpr std::size_t index = N::value; - return hana::at_c<index>(static_cast<Xs&&>(xs).storage_); - } - }; - - template <> - struct drop_front_impl<tuple_tag> { - template <std::size_t N, typename Xs, std::size_t ...i> - static constexpr auto helper(Xs&& xs, std::index_sequence<i...>) { - return hana::make<tuple_tag>(hana::at_c<i+N>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename N> - static constexpr auto apply(Xs&& xs, N const&) { - constexpr std::size_t len = decltype(hana::length(xs))::value; - return helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence< - N::value < len ? len - N::value : 0 - >{}); - } - }; - - template <> - struct is_empty_impl<tuple_tag> { - template <typename ...Xs> - static constexpr auto apply(tuple<Xs...> const&) - { return hana::bool_c<sizeof...(Xs) == 0>; } - }; - - // compile-time optimizations (to reduce the # of function instantiations) - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(tuple<Xs...> const& xs) { - return hana::at_c<n>(xs.storage_); - } - - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(tuple<Xs...>& xs) { - return hana::at_c<n>(xs.storage_); - } - - template <std::size_t n, typename ...Xs> - constexpr decltype(auto) at_c(tuple<Xs...>&& xs) { - return hana::at_c<n>(static_cast<tuple<Xs...>&&>(xs).storage_); - } - - template <> - struct index_if_impl<tuple_tag> { - template <typename ...Xs, typename Pred> - static constexpr auto apply(tuple<Xs...> const&, Pred const&) - -> typename detail::index_if<Pred, Xs...>::type - { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Sequence - ////////////////////////////////////////////////////////////////////////// - template <> - struct Sequence<tuple_tag> { - static constexpr bool value = true; - }; - - template <> - struct make_impl<tuple_tag> { - template <typename ...Xs> - static constexpr - tuple<typename detail::decay<Xs>::type...> apply(Xs&& ...xs) - { return {static_cast<Xs&&>(xs)...}; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TUPLE_HPP diff --git a/contrib/restricted/boost/boost/hana/type.hpp b/contrib/restricted/boost/boost/hana/type.hpp deleted file mode 100644 index 80a498753f..0000000000 --- a/contrib/restricted/boost/boost/hana/type.hpp +++ /dev/null @@ -1,245 +0,0 @@ -/*! -@file -Defines `boost::hana::type` and related utilities. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_TYPE_HPP -#define BOOST_HANA_TYPE_HPP - -#include <boost/hana/fwd/type.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/operators/adl.hpp> -#include <boost/hana/detail/operators/comparable.hpp> -#include <boost/hana/fwd/concept/metafunction.hpp> -#include <boost/hana/fwd/core/make.hpp> -#include <boost/hana/fwd/equal.hpp> -#include <boost/hana/fwd/hash.hpp> -#include <boost/hana/integral_constant.hpp> - -#include <type_traits> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - ////////////////////////////////////////////////////////////////////////// - // basic_type - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename T> - struct basic_type : detail::operators::adl<basic_type<T>> { - using hana_tag = type_tag; - - using type = T; - constexpr auto operator+() const { return *this; } - }; - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // type - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct type_impl { - struct _ : basic_type<T> { }; - }; - - ////////////////////////////////////////////////////////////////////////// - // decltype_ - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename T, typename = type_tag> - struct decltype_t { - using type = typename std::remove_reference<T>::type; - }; - - template <typename T> - struct decltype_t<T, typename hana::tag_of<T>::type> { - using type = typename std::remove_reference<T>::type::type; - }; - } - - //! @cond - template <typename T> - constexpr auto decltype_t::operator()(T&&) const - { return hana::type_c<typename detail::decltype_t<T>::type>; } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // typeid_ - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename T, typename = type_tag> - struct typeid_t { - using type = typename std::remove_cv< - typename std::remove_reference<T>::type - >::type; - }; - - template <typename T> - struct typeid_t<T, typename hana::tag_of<T>::type> { - using type = typename std::remove_reference<T>::type::type; - }; - } - //! @cond - template <typename T> - constexpr auto typeid_t::operator()(T&&) const - { return hana::type_c<typename detail::typeid_t<T>::type>; } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // make<type_tag> - ////////////////////////////////////////////////////////////////////////// - template <> - struct make_impl<type_tag> { - template <typename T> - static constexpr auto apply(T&& t) - { return hana::typeid_(static_cast<T&&>(t)); } - }; - - ////////////////////////////////////////////////////////////////////////// - // sizeof_ - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename T> - constexpr auto sizeof_t::operator()(T&&) const - { return hana::size_c<sizeof(typename detail::decltype_t<T>::type)>; } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // alignof_ - ////////////////////////////////////////////////////////////////////////// - //! @cond - template <typename T> - constexpr auto alignof_t::operator()(T&&) const - { return hana::size_c<alignof(typename detail::decltype_t<T>::type)>; } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // is_valid - ////////////////////////////////////////////////////////////////////////// - namespace type_detail { - template <typename F, typename ...Args, typename = decltype( - std::declval<F&&>()(std::declval<Args&&>()...) - )> - constexpr auto is_valid_impl(int) { return hana::true_c; } - - template <typename F, typename ...Args> - constexpr auto is_valid_impl(...) { return hana::false_c; } - - template <typename F> - struct is_valid_fun { - template <typename ...Args> - constexpr auto operator()(Args&& ...) const - { return is_valid_impl<F, Args&&...>(int{}); } - }; - } - - //! @cond - template <typename F> - constexpr auto is_valid_t::operator()(F&&) const - { return type_detail::is_valid_fun<F&&>{}; } - - template <typename F, typename ...Args> - constexpr auto is_valid_t::operator()(F&&, Args&& ...) const - { return type_detail::is_valid_impl<F&&, Args&&...>(int{}); } - //! @endcond - - ////////////////////////////////////////////////////////////////////////// - // template_ - ////////////////////////////////////////////////////////////////////////// - template <template <typename ...> class F> - struct template_t { - template <typename ...T> - struct apply { - using type = F<T...>; - }; - - template <typename ...T> - constexpr auto operator()(T const& ...) const - { return hana::type<F<typename T::type...>>{}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // metafunction - ////////////////////////////////////////////////////////////////////////// - template <template <typename ...> class F> - struct metafunction_t { - template <typename ...T> - using apply = F<T...>; - - template <typename ...T> - constexpr hana::type<typename F<typename T::type...>::type> - operator()(T const& ...) const { return {}; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Metafunction - ////////////////////////////////////////////////////////////////////////// - template <template <typename ...> class F> - struct Metafunction<template_t<F>> { - static constexpr bool value = true; - }; - - template <template <typename ...> class F> - struct Metafunction<metafunction_t<F>> { - static constexpr bool value = true; - }; - - template <typename F> - struct Metafunction<metafunction_class_t<F>> { - static constexpr bool value = true; - }; - - ////////////////////////////////////////////////////////////////////////// - // integral - ////////////////////////////////////////////////////////////////////////// - template <typename F> - struct integral_t { - template <typename ...T> - constexpr auto operator()(T const& ...) const { - using Result = typename F::template apply<typename T::type...>::type; - return Result{}; - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Operators - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <> - struct comparable_operators<type_tag> { - static constexpr bool value = true; - }; - } - - ////////////////////////////////////////////////////////////////////////// - // Comparable - ////////////////////////////////////////////////////////////////////////// - template <> - struct equal_impl<type_tag, type_tag> { - template <typename T, typename U> - static constexpr auto apply(basic_type<T> const&, basic_type<U> const&) - { return hana::false_c; } - - template <typename T> - static constexpr auto apply(basic_type<T> const&, basic_type<T> const&) - { return hana::true_c; } - }; - - ////////////////////////////////////////////////////////////////////////// - // Hashable - ////////////////////////////////////////////////////////////////////////// - template <> - struct hash_impl<hana::type_tag> { - template <typename T> - static constexpr T apply(T const& t) - { return t; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_TYPE_HPP diff --git a/contrib/restricted/boost/boost/hana/unfold_left.hpp b/contrib/restricted/boost/boost/hana/unfold_left.hpp deleted file mode 100644 index d058ac06b2..0000000000 --- a/contrib/restricted/boost/boost/hana/unfold_left.hpp +++ /dev/null @@ -1,71 +0,0 @@ -/*! -@file -Defines `boost::hana::unfold_left`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_UNFOLD_LEFT_HPP -#define BOOST_HANA_UNFOLD_LEFT_HPP - -#include <boost/hana/fwd/unfold_left.hpp> - -#include <boost/hana/append.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/second.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename S> - struct unfold_left_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::unfold_left<S> requires 'S' to be a Sequence"); - #endif - - template <typename State, typename F> - constexpr auto operator()(State&& state, F&& f) const { - return unfold_left_impl<S>::apply( - static_cast<State&&>(state), - static_cast<F&&>(f) - ); - } - }; - //! @endcond - - template <typename S, bool condition> - struct unfold_left_impl<S, when<condition>> : default_ { - struct unfold_left_helper { - template <typename F, typename P> - constexpr auto operator()(F&& f, P&& p) const { - return hana::append( - unfold_left_impl::apply( - hana::first(static_cast<P&&>(p)), - static_cast<F&&>(f) - ), - hana::second(static_cast<P&&>(p)) - ); - } - }; - - template <typename Init, typename F> - static constexpr auto apply(Init&& init, F&& f) { - decltype(auto) elt = f(static_cast<Init&&>(init)); - return hana::maybe(empty<S>(), - hana::partial(unfold_left_helper{}, static_cast<F&&>(f)), - static_cast<decltype(elt)&&>(elt) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_UNFOLD_LEFT_HPP diff --git a/contrib/restricted/boost/boost/hana/unfold_right.hpp b/contrib/restricted/boost/boost/hana/unfold_right.hpp deleted file mode 100644 index f9917bd7e1..0000000000 --- a/contrib/restricted/boost/boost/hana/unfold_right.hpp +++ /dev/null @@ -1,71 +0,0 @@ -/*! -@file -Defines `boost::hana::unfold_right`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_UNFOLD_RIGHT_HPP -#define BOOST_HANA_UNFOLD_RIGHT_HPP - -#include <boost/hana/fwd/unfold_right.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/empty.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/optional.hpp> -#include <boost/hana/prepend.hpp> -#include <boost/hana/second.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename S> - struct unfold_right_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::unfold_right<S> requires 'S' to be a Sequence"); - #endif - - template <typename State, typename F> - constexpr auto operator()(State&& state, F&& f) const { - return unfold_right_impl<S>::apply( - static_cast<State&&>(state), - static_cast<F&&>(f) - ); - } - }; - //! @endcond - - template <typename S, bool condition> - struct unfold_right_impl<S, when<condition>> : default_ { - struct unfold_right_helper { - template <typename F, typename P> - constexpr auto operator()(F&& f, P&& p) const { - return hana::prepend( - unfold_right_impl::apply( - hana::second(static_cast<P&&>(p)), - static_cast<F&&>(f) - ), - hana::first(static_cast<P&&>(p)) - ); - } - }; - - template <typename Init, typename F> - static constexpr auto apply(Init&& init, F&& f) { - decltype(auto) elt = f(static_cast<Init&&>(init)); - return hana::maybe(hana::empty<S>(), - hana::partial(unfold_right_helper{}, static_cast<F&&>(f)), - static_cast<decltype(elt)&&>(elt) - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_UNFOLD_RIGHT_HPP diff --git a/contrib/restricted/boost/boost/hana/union.hpp b/contrib/restricted/boost/boost/hana/union.hpp deleted file mode 100644 index d7bb4403bf..0000000000 --- a/contrib/restricted/boost/boost/hana/union.hpp +++ /dev/null @@ -1,39 +0,0 @@ -/*! -@file -Defines `boost::hana::union`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_UNION_HPP -#define BOOST_HANA_UNION_HPP - -#include <boost/hana/fwd/union.hpp> - -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename Ys> - constexpr auto union_t::operator()(Xs&& xs, Ys&& ys) const { - using S = typename hana::tag_of<Xs>::type; - using Union = BOOST_HANA_DISPATCH_IF(union_impl<S>, - true - ); - - return Union::apply(static_cast<Xs&&>(xs), static_cast<Ys&&>(ys)); - } - //! @endcond - - template <typename S, bool condition> - struct union_impl<S, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_UNION_HPP diff --git a/contrib/restricted/boost/boost/hana/unique.hpp b/contrib/restricted/boost/boost/hana/unique.hpp deleted file mode 100644 index 9485c332f0..0000000000 --- a/contrib/restricted/boost/boost/hana/unique.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*! -@file -Defines `boost::hana::unique`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_UNIQUE_HPP -#define BOOST_HANA_UNIQUE_HPP - -#include <boost/hana/fwd/unique.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/nested_by.hpp> // required by fwd decl -#include <boost/hana/equal.hpp> -#include <boost/hana/front.hpp> -#include <boost/hana/group.hpp> -#include <boost/hana/transform.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs> - constexpr auto unique_t::operator()(Xs&& xs) const { - using S = typename hana::tag_of<Xs>::type; - using Unique = BOOST_HANA_DISPATCH_IF(unique_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::unique(xs) requires 'xs' to be a Sequence"); - #endif - - return Unique::apply(static_cast<Xs&&>(xs)); - } - - template <typename Xs, typename Predicate> - constexpr auto unique_t::operator()(Xs&& xs, Predicate&& predicate) const { - using S = typename hana::tag_of<Xs>::type; - using Unique = BOOST_HANA_DISPATCH_IF(unique_impl<S>, - hana::Sequence<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Sequence<S>::value, - "hana::unique(xs, predicate) requires 'xs' to be a Sequence"); - #endif - - return Unique::apply(static_cast<Xs&&>(xs), - static_cast<Predicate&&>(predicate)); - } - //! @endcond - - template <typename S, bool condition> - struct unique_impl<S, when<condition>> : default_ { - template <typename Xs, typename Pred> - static constexpr auto apply(Xs&& xs, Pred&& pred) { - return hana::transform( - hana::group(static_cast<Xs&&>(xs), static_cast<Pred&&>(pred)), - hana::front - ); - } - - template <typename Xs> - static constexpr auto apply(Xs&& xs) - { return unique_impl::apply(static_cast<Xs&&>(xs), hana::equal); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_UNIQUE_HPP diff --git a/contrib/restricted/boost/boost/hana/unpack.hpp b/contrib/restricted/boost/boost/hana/unpack.hpp deleted file mode 100644 index 485821ea7a..0000000000 --- a/contrib/restricted/boost/boost/hana/unpack.hpp +++ /dev/null @@ -1,141 +0,0 @@ -/*! -@file -Defines `boost::hana::unpack`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_UNPACK_HPP -#define BOOST_HANA_UNPACK_HPP - -#include <boost/hana/fwd/unpack.hpp> - -#include <boost/hana/accessors.hpp> -#include <boost/hana/at.hpp> -#include <boost/hana/concept/foldable.hpp> -#include <boost/hana/concept/iterable.hpp> -#include <boost/hana/concept/struct.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/first.hpp> -#include <boost/hana/functional/partial.hpp> -#include <boost/hana/fwd/fold_left.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/pair.hpp> -#include <boost/hana/second.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename F> - constexpr decltype(auto) unpack_t::operator()(Xs&& xs, F&& f) const { - using S = typename hana::tag_of<Xs>::type; - using Unpack = BOOST_HANA_DISPATCH_IF(unpack_impl<S>, - hana::Foldable<S>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Foldable<S>::value, - "hana::unpack(xs, f) requires 'xs' to be Foldable"); - #endif - - return Unpack::apply(static_cast<Xs&&>(xs), static_cast<F&&>(f)); - } - //! @endcond - - template <typename T, bool condition> - struct unpack_impl<T, when<condition>> : default_ { - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - return hana::fold_left(static_cast<Xs&&>(xs), - static_cast<F&&>(f), - hana::partial)(); - } - }; - - template <typename It> - struct unpack_impl<It, when< - hana::Iterable<It>::value && !is_default<length_impl<It>>::value - >> { - template <typename Xs, typename F, std::size_t ...i> - static constexpr decltype(auto) - unpack_helper(Xs&& xs, F&& f, std::index_sequence<i...>) { - return static_cast<F&&>(f)(hana::at_c<i>(static_cast<Xs&&>(xs))...); - } - - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - constexpr std::size_t N = decltype(hana::length(xs))::value; - return unpack_helper(static_cast<Xs&&>(xs), static_cast<F&&>(f), - std::make_index_sequence<N>{}); - } - }; - - template <typename T, std::size_t N> - struct unpack_impl<T[N]> { - template <typename Xs, typename F, std::size_t ...i> - static constexpr decltype(auto) - unpack_helper(Xs&& xs, F&& f, std::index_sequence<i...>) { - return static_cast<F&&>(f)(static_cast<Xs&&>(xs)[i]...); - } - - template <typename Xs, typename F> - static constexpr decltype(auto) apply(Xs&& xs, F&& f) { - return unpack_impl::unpack_helper(static_cast<Xs&&>(xs), - static_cast<F&&>(f), - std::make_index_sequence<N>{}); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Products - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct unpack_impl<T, when<hana::Product<T>::value>> { - template <typename P, typename F> - static constexpr decltype(auto) apply(P&& p, F&& f) { - return static_cast<F&&>(f)( - hana::first(static_cast<P&&>(p)), - hana::second(static_cast<P&&>(p)) - ); - } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Structs - ////////////////////////////////////////////////////////////////////////// - namespace struct_detail { - // This is equivalent to `demux`, except that `demux` can't forward - // the `udt` because it does not know the `g`s are accessors. Hence, - // this can result in faster code. - struct almost_demux { - template <typename F, typename Udt, typename ...Members> - constexpr decltype(auto) - operator()(F&& f, Udt&& udt, Members&& ...g) const { - return static_cast<F&&>(f)(hana::make_pair( - hana::first(static_cast<Members&&>(g)), - hana::second(static_cast<Members&&>(g)) - (static_cast<Udt&&>(udt)) - )...); - } - }; - } - - template <typename S> - struct unpack_impl<S, when<hana::Struct<S>::value>> { - template <typename Udt, typename F> - static constexpr decltype(auto) apply(Udt&& udt, F&& f) { - return hana::unpack(hana::accessors<S>(), - hana::partial(struct_detail::almost_demux{}, - static_cast<F&&>(f), - static_cast<Udt&&>(udt))); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_UNPACK_HPP diff --git a/contrib/restricted/boost/boost/hana/value.hpp b/contrib/restricted/boost/boost/hana/value.hpp deleted file mode 100644 index 52d0581853..0000000000 --- a/contrib/restricted/boost/boost/hana/value.hpp +++ /dev/null @@ -1,56 +0,0 @@ -/*! -@file -Defines `boost::hana::value`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_VALUE_HPP -#define BOOST_HANA_VALUE_HPP - -#include <boost/hana/fwd/value.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/integral_constant.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename C, bool condition> - struct value_impl<C, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...args) = delete; - }; - - template <typename T> - constexpr decltype(auto) value() { - using RawT = typename std::remove_cv< - typename std::remove_reference<T>::type - >::type; - using C = typename hana::tag_of<RawT>::type; - using Value = BOOST_HANA_DISPATCH_IF( - value_impl<C>, hana::Constant<C>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Constant<C>::value, - "hana::value<T>() requires 'T' to be a Constant"); - #endif - - return Value::template apply<RawT>(); - } - - template <typename I> - struct value_impl<I, when<hana::IntegralConstant<I>::value>> { - template <typename C> - static constexpr auto apply() - { return C::value; } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_VALUE_HPP diff --git a/contrib/restricted/boost/boost/hana/version.hpp b/contrib/restricted/boost/boost/hana/version.hpp deleted file mode 100644 index 70ba6fd9a1..0000000000 --- a/contrib/restricted/boost/boost/hana/version.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*! -@file -Defines macros for tracking the version of the library. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_VERSION_HPP -#define BOOST_HANA_VERSION_HPP - -//! @internal -//! Transforms a (version, revision, patchlevel) triple into a number of the -//! form 0xVVRRPPPP to allow comparing versions in a normalized way. -//! -//! See http://sourceforge.net/p/predef/wiki/VersionNormalization. -#define BOOST_HANA_CONFIG_VERSION(version, revision, patch) \ - (((version) << 24) + ((revision) << 16) + (patch)) - -//! @ingroup group-config -//! Macro expanding to the major version of the library, i.e. the `x` in `x.y.z`. -#define BOOST_HANA_MAJOR_VERSION 1 - -//! @ingroup group-config -//! Macro expanding to the minor version of the library, i.e. the `y` in `x.y.z`. -#define BOOST_HANA_MINOR_VERSION 4 - -//! @ingroup group-config -//! Macro expanding to the patch level of the library, i.e. the `z` in `x.y.z`. -#define BOOST_HANA_PATCH_VERSION 0 - -//! @ingroup group-config -//! Macro expanding to the full version of the library, in hexadecimal -//! representation. -//! -//! Specifically, `BOOST_HANA_VERSION` expands to an hexadecimal number of the -//! form 0xVVRRPPPP, where `VV` is the major version of the library, `RR` is -//! the minor version and `PPPP` is the patch level. This allows the version -//! of the library to be compared: -//! @snippet example/version.cpp main -//! -//! -//! @note -//! The major, minor and patch versions of the library are also available -//! individually with the `BOOST_HANA_{MAJOR,MINOR,PATCH}_VERSION` macros. -#define BOOST_HANA_VERSION \ - BOOST_HANA_CONFIG_VERSION(BOOST_HANA_MAJOR_VERSION, \ - BOOST_HANA_MINOR_VERSION, \ - BOOST_HANA_PATCH_VERSION) \ -/**/ - -#endif // !BOOST_HANA_VERSION_HPP diff --git a/contrib/restricted/boost/boost/hana/while.hpp b/contrib/restricted/boost/boost/hana/while.hpp deleted file mode 100644 index 312494daf5..0000000000 --- a/contrib/restricted/boost/boost/hana/while.hpp +++ /dev/null @@ -1,117 +0,0 @@ -/*! -@file -Defines `boost::hana::while_`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_WHILE_HPP -#define BOOST_HANA_WHILE_HPP - -#include <boost/hana/fwd/while.hpp> - -#include <boost/hana/bool.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/logical.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Pred, typename State, typename F> - constexpr decltype(auto) while_t::operator()(Pred&& pred, State&& state, F&& f) const { - using Cond = decltype(pred(state)); - using Bool = typename hana::tag_of<Cond>::type; - using While = BOOST_HANA_DISPATCH_IF(while_impl<Bool>, - hana::Logical<Bool>::value - ); - - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Logical<Bool>::value, - "hana::while_(pred, state, f) requires 'pred(state)' to be a Logical"); - #endif - - return While::apply(static_cast<Pred&&>(pred), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - //! @endcond - - template <typename L, bool condition> - struct while_impl<L, hana::when<condition>> : hana::default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - template <typename L> - struct while_impl<L, hana::when<std::is_arithmetic<L>::value>> { - template <typename Pred, typename State, typename F> - static auto apply(Pred&& pred, State&& state, F&& f) - -> decltype( - true ? f(static_cast<State&&>(state)) - : static_cast<State&&>(state) - ) - { - if (pred(state)) { - decltype(auto) r = f(static_cast<State&&>(state)); - return hana::while_(static_cast<Pred&&>(pred), - static_cast<decltype(r)&&>(r), - static_cast<F&&>(f)); - } - else { - return static_cast<State&&>(state); - } - } - }; - - template <typename C> - struct while_impl<C, hana::when< - hana::Constant<C>::value && - hana::Logical<typename C::value_type>::value - >> { - template <typename Pred, typename State, typename F> - static constexpr State - while_helper(hana::false_, Pred&&, State&& state, F&&) { - return static_cast<State&&>(state); - } - - template <typename Pred, typename State, typename F> - static constexpr decltype(auto) - while_helper(hana::true_, Pred&& pred, State&& state, F&& f) { - decltype(auto) r = f(static_cast<State&&>(state)); - return hana::while_(static_cast<Pred&&>(pred), - static_cast<decltype(r)&&>(r), - static_cast<F&&>(f)); - } - - template <typename Pred, typename State, typename F> - static constexpr decltype(auto) - apply(Pred&& pred, State&& state, F&& f) { - // Since `pred(state)` returns a `Constant`, we do not actually - // need to call it; we only need its decltype. However, we still - // call it to run potential side effects. I'm not sure whether - // that is desirable, since we pretty much take for granted that - // functions are pure, but we'll do it like this for now. Also, I - // think there is something rather deep hidden behind this, and - // understanding what must be done here should give us a better - // understanding of something non-trivial. - auto cond_ = pred(state); - constexpr auto cond = hana::value(cond_); - constexpr bool truth_value = hana::if_(cond, true, false); - return while_helper(hana::bool_c<truth_value>, - static_cast<Pred&&>(pred), - static_cast<State&&>(state), - static_cast<F&&>(f)); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_WHILE_HPP diff --git a/contrib/restricted/boost/boost/hana/zero.hpp b/contrib/restricted/boost/boost/hana/zero.hpp deleted file mode 100644 index baba9691f6..0000000000 --- a/contrib/restricted/boost/boost/hana/zero.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*! -@file -Defines `boost::hana::zero`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ZERO_HPP -#define BOOST_HANA_ZERO_HPP - -#include <boost/hana/fwd/zero.hpp> - -#include <boost/hana/concept/constant.hpp> -#include <boost/hana/concept/monoid.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/to.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/canonical_constant.hpp> - -#include <type_traits> - - -BOOST_HANA_NAMESPACE_BEGIN - template <typename M> - struct zero_t { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(hana::Monoid<M>::value, - "hana::zero<M>() requires 'M' to be a Monoid"); - #endif - - constexpr decltype(auto) operator()() const { - using Zero = BOOST_HANA_DISPATCH_IF(zero_impl<M>, - hana::Monoid<M>::value - ); - - return Zero::apply(); - } - }; - - template <typename M, bool condition> - struct zero_impl<M, when<condition>> : default_ { - template <typename ...Args> - static constexpr auto apply(Args&& ...) = delete; - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for non-boolean arithmetic data types - ////////////////////////////////////////////////////////////////////////// - template <typename T> - struct zero_impl<T, when< - std::is_arithmetic<T>::value && - !std::is_same<T, bool>::value - >> { - static constexpr T apply() - { return static_cast<T>(0); } - }; - - ////////////////////////////////////////////////////////////////////////// - // Model for Constants over a Monoid - ////////////////////////////////////////////////////////////////////////// - namespace detail { - template <typename C> - struct constant_from_zero { - static constexpr auto value = hana::zero<typename C::value_type>(); - using hana_tag = detail::CanonicalConstant<typename C::value_type>; - }; - } - - template <typename C> - struct zero_impl<C, when< - hana::Constant<C>::value && - Monoid<typename C::value_type>::value - >> { - static constexpr decltype(auto) apply() - { return hana::to<C>(detail::constant_from_zero<C>{}); } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ZERO_HPP diff --git a/contrib/restricted/boost/boost/hana/zip.hpp b/contrib/restricted/boost/boost/hana/zip.hpp deleted file mode 100644 index d18f3ef5e7..0000000000 --- a/contrib/restricted/boost/boost/hana/zip.hpp +++ /dev/null @@ -1,50 +0,0 @@ -/*! -@file -Defines `boost::hana::zip`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ZIP_HPP -#define BOOST_HANA_ZIP_HPP - -#include <boost/hana/fwd/zip.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/tuple.hpp> -#include <boost/hana/zip_with.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename ...Ys> - constexpr auto zip_t::operator()(Xs&& xs, Ys&& ...ys) const { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(detail::fast_and< - hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... - >::value, - "hana::zip(xs, ys...) requires 'xs' and 'ys...' to be Sequences"); - #endif - - return zip_impl<typename hana::tag_of<Xs>::type>::apply( - static_cast<Xs&&>(xs), - static_cast<Ys&&>(ys)... - ); - } - //! @endcond - - template <typename S, bool condition> - struct zip_impl<S, when<condition>> : default_ { - template <typename ...Xs> - static constexpr decltype(auto) apply(Xs&& ...xs) { - return hana::zip_with(hana::make_tuple, static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ZIP_HPP diff --git a/contrib/restricted/boost/boost/hana/zip_shortest.hpp b/contrib/restricted/boost/boost/hana/zip_shortest.hpp deleted file mode 100644 index 761ca188c5..0000000000 --- a/contrib/restricted/boost/boost/hana/zip_shortest.hpp +++ /dev/null @@ -1,51 +0,0 @@ -/*! -@file -Defines `boost::hana::zip_shortest`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ZIP_SHORTEST_HPP -#define BOOST_HANA_ZIP_SHORTEST_HPP - -#include <boost/hana/fwd/zip_shortest.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/tuple.hpp> -#include <boost/hana/zip_shortest_with.hpp> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename Xs, typename ...Ys> - constexpr auto zip_shortest_t::operator()(Xs&& xs, Ys&& ...ys) const { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(detail::fast_and< - hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... - >::value, - "hana::zip_shortest(xs, ys...) requires 'xs' and 'ys...' to be Sequences"); - #endif - - return zip_shortest_impl<typename hana::tag_of<Xs>::type>::apply( - static_cast<Xs&&>(xs), - static_cast<Ys&&>(ys)... - ); - } - //! @endcond - - template <typename S, bool condition> - struct zip_shortest_impl<S, when<condition>> : default_ { - template <typename ...Xs> - static constexpr decltype(auto) apply(Xs&& ...xs) { - return hana::zip_shortest_with(hana::make_tuple, - static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ZIP_SHORTEST_HPP diff --git a/contrib/restricted/boost/boost/hana/zip_shortest_with.hpp b/contrib/restricted/boost/boost/hana/zip_shortest_with.hpp deleted file mode 100644 index fc43f35239..0000000000 --- a/contrib/restricted/boost/boost/hana/zip_shortest_with.hpp +++ /dev/null @@ -1,64 +0,0 @@ -/*! -@file -Defines `boost::hana::zip_shortest_with`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ZIP_SHORTEST_WITH_HPP -#define BOOST_HANA_ZIP_SHORTEST_WITH_HPP - -#include <boost/hana/fwd/zip_shortest_with.hpp> - -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/detail/algorithm.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/integral_constant.hpp> -#include <boost/hana/length.hpp> -#include <boost/hana/take_front.hpp> -#include <boost/hana/zip_with.hpp> - -#include <cstddef> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename F, typename Xs, typename ...Ys> - constexpr auto - zip_shortest_with_t::operator()(F&& f, Xs&& xs, Ys&& ...ys) const { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(detail::fast_and< - hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... - >::value, - "hana::zip_shortest_with(f, xs, ys...) requires 'xs' and 'ys...' to be Sequences"); - #endif - - return zip_shortest_with_impl<typename hana::tag_of<Xs>::type>::apply( - static_cast<F&&>(f), - static_cast<Xs&&>(xs), - static_cast<Ys&&>(ys)... - ); - } - //! @endcond - - template <typename S, bool condition> - struct zip_shortest_with_impl<S, when<condition>> : default_ { - template <typename F, typename ...Xs> - static constexpr decltype(auto) apply(F&& f, Xs&& ...xs) { - constexpr std::size_t lengths[] = { - decltype(hana::length(xs))::value... - }; - constexpr std::size_t min_len = - *detail::min_element(lengths, lengths + sizeof...(xs)); - return hana::zip_with(static_cast<F&&>(f), - hana::take_front(static_cast<Xs&&>(xs), hana::size_c<min_len>)... - ); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ZIP_SHORTEST_WITH_HPP diff --git a/contrib/restricted/boost/boost/hana/zip_with.hpp b/contrib/restricted/boost/boost/hana/zip_with.hpp deleted file mode 100644 index 8a5e153fe0..0000000000 --- a/contrib/restricted/boost/boost/hana/zip_with.hpp +++ /dev/null @@ -1,70 +0,0 @@ -/*! -@file -Defines `boost::hana::zip_with`. - -@copyright Louis Dionne 2013-2017 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - */ - -#ifndef BOOST_HANA_ZIP_WITH_HPP -#define BOOST_HANA_ZIP_WITH_HPP - -#include <boost/hana/fwd/zip_with.hpp> - -#include <boost/hana/at.hpp> -#include <boost/hana/concept/sequence.hpp> -#include <boost/hana/config.hpp> -#include <boost/hana/core/dispatch.hpp> -#include <boost/hana/core/make.hpp> -#include <boost/hana/detail/fast_and.hpp> -#include <boost/hana/length.hpp> - -#include <cstddef> -#include <utility> - - -BOOST_HANA_NAMESPACE_BEGIN - //! @cond - template <typename F, typename Xs, typename ...Ys> - constexpr auto zip_with_t::operator()(F&& f, Xs&& xs, Ys&& ...ys) const { - #ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS - static_assert(detail::fast_and< - hana::Sequence<Xs>::value, hana::Sequence<Ys>::value... - >::value, - "hana::zip_with(f, xs, ys...) requires 'xs' and 'ys...' to be Sequences"); - #endif - - return zip_with_impl<typename hana::tag_of<Xs>::type>::apply( - static_cast<F&&>(f), - static_cast<Xs&&>(xs), - static_cast<Ys&&>(ys)... - ); - } - //! @endcond - - template <typename S> - struct zip_with_impl<S, when<Sequence<S>::value>> { - template <std::size_t N, typename F, typename ...Xs> - static constexpr decltype(auto) transverse(F&& f, Xs&& ...xs) { - return static_cast<F&&>(f)(hana::at_c<N>(static_cast<Xs&&>(xs))...); - } - - template <std::size_t ...N, typename F, typename ...Xs> - static constexpr auto - zip_helper(std::index_sequence<N...>, F&& f, Xs&& ...xs) { - return hana::make<S>(transverse<N>(f, xs...)...); - } - - template <typename F, typename X, typename ...Xs> - static constexpr auto - apply(F&& f, X&& x, Xs&& ...xs) { - constexpr std::size_t N = decltype(hana::length(x))::value; - return zip_helper(std::make_index_sequence<N>{}, - static_cast<F&&>(f), - static_cast<X&&>(x), static_cast<Xs&&>(xs)...); - } - }; -BOOST_HANA_NAMESPACE_END - -#endif // !BOOST_HANA_ZIP_WITH_HPP diff --git a/contrib/restricted/boost/hana/CONTRIBUTING.md b/contrib/restricted/boost/hana/CONTRIBUTING.md new file mode 100644 index 0000000000..403fae5c60 --- /dev/null +++ b/contrib/restricted/boost/hana/CONTRIBUTING.md @@ -0,0 +1,60 @@ +# How to contribute + +Contributions are always very much appreciated. However, to make sure the +process of accepting patches goes smoothly for everyone (especially for +the maintainer), you should try to follow these few simple guidelines when +you contribute: + +1. Fork the repository. +2. Create a new branch based on the `develop` branch (`git checkout -b your_branch develop`). + If your contribution is a bug fix, you should name your branch `bugfix/xxx`; + for a feature, it should be `feature/xxx`. Otherwise, just use your good + judgment. Consistent naming of branches is appreciated since it makes the + output of `git branch` easier to understand with a single glance. +3. Do your modifications on that branch. Except for special cases, your + contribution should include proper unit tests and documentation. Also, + please try to follow the style guide below. +4. Make sure your modifications did not break anything by building and + running the tests: + + ```shell + make check + ``` +5. Commit your changes. Your commit message should start with a one line + short description of the modifications, with the details and explanations + of your modifications following in subsequent paragraphs or bullet points. + Please limit your lines to about 78 characters in commit messages, since + it makes the output easier to read in `git log`. Also, starting your commit + message with a tag describing the nature of the commit is nice, since it + makes the commit history easier to skim through. For commits that do not + change any functionality (e.g. refactoring or fixing typos), the `[NFC]` + tag (No Functionality Change) can be used. Here's an example of an + acceptable commit message: + ``` + [Searchable] Refactor the interface + + - Rename elem to contains + - Rename subset to is_subset, and make is_subset applicable in infix notation + - Add the at_key method + - operator[] is now bound to at_key instead of find + ``` + When applicable, please squash adjacent _wip_ commits into a single + _logical_ commit. If your contribution has several logical commits, + it's fine. +6. Push the changes to your fork (`git push origin your_branch`). +7. Open a pull request against Hana's `develop` branch (not against `master`). + I will do my best to respond in a timely manner. I might discuss your patch + and suggest some modifications, or I might amend your patch myself and ask + you for feedback. You will always be given proper credit. + + +## Style guide + +I'm not going to write an exhaustive style guide, but here are a couple of +points you should watch out for: +- Indent using 4 spaces. +- Do not leave trailing white spaces at the end of lines, and no more than a + single newline at the end of a source file. +- Hana's `#include`s go first, then a blank line and system headers. + `#include`s within each block should be sorted in alphabetical order. +- Use your own judgment and stick to the style of the surrounding code. diff --git a/contrib/restricted/boost/hana/LICENSE.md b/contrib/restricted/boost/hana/LICENSE.md new file mode 100644 index 0000000000..8639127154 --- /dev/null +++ b/contrib/restricted/boost/hana/LICENSE.md @@ -0,0 +1,25 @@ +Copyright Louis Dionne 2013-2017 + +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/contrib/restricted/boost/hana/README.md b/contrib/restricted/boost/hana/README.md new file mode 100644 index 0000000000..b4ef11bb35 --- /dev/null +++ b/contrib/restricted/boost/hana/README.md @@ -0,0 +1,202 @@ +# Boost.Hana <a target="_blank" href="http://semver.org">![Version][badge.version]</a> <a target="_blank" href="https://travis-ci.org/boostorg/hana">![Travis status][badge.Travis]</a> <a target="_blank" href="https://ci.appveyor.com/project/ldionne/hana">![Appveyor status][badge.Appveyor]</a> <a target="_blank" href="http://melpon.org/wandbox/permlink/g4ozIK33ITDtyGa3">![Try it online][badge.wandbox]</a> <a target="_blank" href="https://gitter.im/boostorg/hana">![Gitter Chat][badge.Gitter]</a> + +> Your standard library for metaprogramming + +## Overview +<!-- Important: keep this in sync with example/overview.cpp --> +```cpp +#include <boost/hana.hpp> +#include <cassert> +#include <string> +namespace hana = boost::hana; +using namespace hana::literals; + +struct Fish { std::string name; }; +struct Cat { std::string name; }; +struct Dog { std::string name; }; + +int main() { + // Sequences capable of holding heterogeneous objects, and algorithms + // to manipulate them. + auto animals = hana::make_tuple(Fish{"Nemo"}, Cat{"Garfield"}, Dog{"Snoopy"}); + auto names = hana::transform(animals, [](auto a) { + return a.name; + }); + assert(hana::reverse(names) == hana::make_tuple("Snoopy", "Garfield", "Nemo")); + + // No compile-time information is lost: even if `animals` can't be a + // constant expression because it contains strings, its length is constexpr. + static_assert(hana::length(animals) == 3u, ""); + + // Computations on types can be performed with the same syntax as that of + // normal C++. Believe it or not, everything is done at compile-time. + auto animal_types = hana::make_tuple(hana::type_c<Fish*>, hana::type_c<Cat&>, hana::type_c<Dog*>); + auto animal_ptrs = hana::filter(animal_types, [](auto a) { + return hana::traits::is_pointer(a); + }); + static_assert(animal_ptrs == hana::make_tuple(hana::type_c<Fish*>, hana::type_c<Dog*>), ""); + + // And many other goodies to make your life easier, including: + // 1. Access to elements in a tuple with a sane syntax. + static_assert(animal_ptrs[0_c] == hana::type_c<Fish*>, ""); + static_assert(animal_ptrs[1_c] == hana::type_c<Dog*>, ""); + + // 2. Unroll loops at compile-time without hassle. + std::string s; + hana::int_c<10>.times([&]{ s += "x"; }); + // equivalent to s += "x"; s += "x"; ... s += "x"; + + // 3. Easily check whether an expression is valid. + // This is usually achieved with complex SFINAE-based tricks. + auto has_name = hana::is_valid([](auto&& x) -> decltype((void)x.name) { }); + static_assert(has_name(animals[0_c]), ""); + static_assert(!has_name(1), ""); +} +``` + + +## Documentation +You can browse the documentation online at http://boostorg.github.io/hana. +The documentation covers everything you should need including installing the +library, a tutorial explaining what Hana is and how to use it, and an extensive +reference section with examples. The remainder of this README is mostly for +people that wish to work on the library itself, not for its users. + +An offline copy of the documentation can be obtained by checking out the +`gh-pages` branch. To avoid overwriting the current directory, you can clone +the `gh-pages` branch into a subdirectory like `doc/html`: +```shell +git clone http://github.com/boostorg/hana --branch=gh-pages --depth=1 doc/html +``` + +After issuing this, `doc/html` will contain exactly the same static website +that is [available online][Hana.docs]. Note that `doc/html` is automatically +ignored by Git so updating the documentation won't pollute your index. + + +## Hacking on Hana +Setting yourself up to work on Hana is easy. First, you will need an +installation of [CMake][]. Once this is done, you can `cd` to the root +of the project and setup the build directory: +```shell +mkdir build +cd build +cmake .. +``` + +Usually, you'll want to specify a custom compiler because the system's +compiler is too old: +```shell +cmake .. -DCMAKE_CXX_COMPILER=/path/to/compiler +``` + +Usually, this will work just fine. However, on some systems, the standard +library and/or compiler provided by default does not support C++14. If +this is your case, the [wiki][Hana.wiki] has more information about +setting you up on different systems. + +Normally, Hana tries to find Boost headers if you have them on your system. +It's also fine if you don't have them; a few tests requiring the Boost headers +will be disabled in that case. However, if you'd like Hana to use a custom +installation of Boost, you can specify the path to this custom installation: +```shell +cmake .. -DCMAKE_CXX_COMPILER=/path/to/compiler -DBOOST_ROOT=/path/to/boost +``` + +You can now build and run the unit tests and the examples: +```shell +cmake --build . --target check +``` + +You should be aware that compiling the unit tests is pretty time and RAM +consuming, especially the tests for external adapters. This is due to the +fact that Hana's unit tests are very thorough, and also that heterogeneous +sequences in other libraries tend to have horrible compile-time performance. + +There are also optional targets which are enabled only when the required +software is available on your computer. For example, generating the +documentation requires [Doxygen][] to be installed. An informative message +will be printed during the CMake generation step whenever an optional target +is disabled. You can install any missing software and then re-run the CMake +generation to update the list of available targets. + +> #### Tip +> You can use the `help` target to get a list of all the available targets. + +If you want to add unit tests or examples, just add a source file in `test/` +or `example/` and then re-run the CMake generation step so the new source +file is known to the build system. Let's suppose the relative path from the +root of the project to the new source file is `path/to/file.cpp`. When you +re-run the CMake generation step, a new target named `path.to.file` will be +created, and a test of the same name will also be created. Hence, +```shell +cd build # Go back to the build directory +cmake --build . --target path.to.file # Builds the program associated to path/to/file.cpp +ctest -R path.to.file # Runs the program as a test +``` + +> #### Tip for Sublime Text users +> If you use the provided [hana.sublime-project](hana.sublime-project) file, +> you can select the "[Hana] Build current file" build system. When viewing a +> file to which a target is associated (like a test or an example), you can +> then compile it by pressing ⌘B, or compile and then run it using ⇧⌘B. + + +## Project organization +The project is organized in a couple of subdirectories. +- The [benchmark](benchmark) directory contains compile-time and runtime + benchmarks to make sure the library is as fast as advertised. The benchmark + code is written mostly in the form of [eRuby][] templates. The templates + are used to generate C++ files which are then compiled while gathering + compilation and execution statistics. +- The [cmake](cmake) directory contains various CMake modules and other + scripts needed by the build system. +- The [doc](doc) directory contains configuration files needed to generate + the documentation. The `doc/html` subdirectory is automatically ignored + by Git; you can conveniently store a local copy of the documentation by + cloning the `gh-pages` branch into that directory, as explained above. +- The [example](example) directory contains the source code for all the + examples of both the tutorial and the reference documentation. +- The [include](include) directory contains the library itself, which is + header only. +- The [test](test) directory contains the source code for all the unit tests. + + +## Contributing +Please see [CONTRIBUTING.md](CONTRIBUTING.md). + + +## License +Please see [LICENSE.md](LICENSE.md). + + +## Releasing +This section acts as a reminder of the few simple steps required to release a +new version of the library. This is only relevant to Hana's developers. To +release a new version of the library, make sure the current version in +`include/boost/hana/version.hpp` matches the release you're about to publish. +Then, create an annotated tag with: +```sh +git tag -a --file=- v<version> <<EOM +...your message here... +EOM +``` + +Then, push the tag and create a new GitHub release pointing to that tag. +Once that is done, bump the version number in `include/boost/hana/version.hpp` +so that it matches the next _planned_ release. Finally, do not forget to update +the [Homebrew formula][] to point to the latest version. + + +<!-- Links --> +[badge.Appveyor]: https://ci.appveyor.com/api/projects/status/github/boostorg/hana?svg=true&branch=master +[badge.Gitter]: https://img.shields.io/badge/gitter-join%20chat-blue.svg +[badge.Travis]: https://travis-ci.org/boostorg/hana.svg?branch=master +[badge.version]: https://badge.fury.io/gh/boostorg%2Fhana.svg +[badge.Wandbox]: https://img.shields.io/badge/try%20it-online-blue.svg +[CMake]: http://www.cmake.org +[Doxygen]: http://www.doxygen.org +[eRuby]: http://en.wikipedia.org/wiki/ERuby +[Hana.docs]: http://boostorg.github.io/hana +[Hana.wiki]: https://github.com/boostorg/hana/wiki +[Homebrew formula]: https://github.com/Homebrew/homebrew-core/blob/master/Formula/hana.rb |