33// Distributed under the Boost Software License, Version 1.0. (See accompanying
44// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
55
6- #ifndef BOOST_PFR_PRECISE_CORE_HPP
7- #define BOOST_PFR_PRECISE_CORE_HPP
6+ #ifndef BOOST_PFR_CORE_HPP
7+ #define BOOST_PFR_CORE_HPP
88#pragma once
99
1010#include < boost/pfr/detail/config.hpp>
1111
12- #include < type_traits>
13- #include < utility> // metaprogramming stuff
12+ #include < boost/pfr/detail/core.hpp>
1413
1514#include < boost/pfr/detail/sequence_tuple.hpp>
1615#include < boost/pfr/detail/stdtuple.hpp>
1716#include < boost/pfr/detail/for_each_field_impl.hpp>
1817#include < boost/pfr/detail/make_integer_sequence.hpp>
18+ #include < boost/pfr/detail/tie_from_structure_tuple.hpp>
1919
20- #include < boost/pfr/precise/tuple_size.hpp>
21- #if BOOST_PFR_USE_CPP17
22- # include < boost/pfr/detail/core17.hpp>
23- #else
24- # include < boost/pfr/detail/core14.hpp>
25- #endif
20+ #include < type_traits>
21+ #include < utility> // metaprogramming stuff
2622
27- #include < boost/pfr/detail/tie_from_structure_tuple.hpp>
23+ #include < boost/pfr/tuple_size.hpp>
24+
25+ // / \file boost/pfr/core.hpp
26+ // / Contains all the basic tuple-like interfaces \forcedlink{get}, \forcedlink{tuple_size}, \forcedlink{tuple_element_t}, and others.
27+ // /
28+ // / \b Synopsis:
2829
2930namespace boost { namespace pfr {
3031
31- // / \brief Returns reference or const reference to a field with index `I` in aggregate T.
32- // /
33- // / \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
32+ // / \brief Returns reference or const reference to a field with index `I` in \aggregate `val`.
3433// /
3534// / \b Example:
3635// / \code
@@ -47,38 +46,52 @@ constexpr decltype(auto) get(const T& val) noexcept {
4746
4847// / \overload get
4948template <std::size_t I, class T >
50- constexpr decltype (auto ) get(T& val) noexcept {
49+ constexpr decltype (auto ) get(T& val
50+ #if !BOOST_PFR_USE_CPP17
51+ , std::enable_if_t <std::is_assignable<T, T>::value>* = nullptr
52+ #endif
53+ ) noexcept {
5154 return detail::sequence_tuple::get<I>( detail::tie_as_tuple (val) );
5255}
5356
57+ #if !BOOST_PFR_USE_CPP17
58+ // / \overload get
59+ template <std::size_t I, class T >
60+ constexpr auto get (T&, std::enable_if_t <!std::is_assignable<T, T>::value>* = nullptr ) noexcept {
61+ static_assert (sizeof (T) && false , " ====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17"
62+ return 0 ;
63+ }
64+ #endif
5465
55- // / \brief `tuple_element` has a `typedef type-of-a-field-with-index-I-in-aggregate-T type;`
56- // /
57- // / \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
66+
67+ // / \overload get
68+ template <std::size_t I, class T >
69+ constexpr auto get (T&& val, std::enable_if_t < std::is_rvalue_reference<T&&>::value>* = 0 ) noexcept {
70+ return std::move (detail::sequence_tuple::get<I>( detail::tie_as_tuple (val) ));
71+ }
72+
73+
74+ // / \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T.
5875// /
5976// / \b Example:
6077// / \code
61- // / std::vector< boost::pfr::tuple_element<0, my_structure>::type > v;
78+ // / std::vector< boost::pfr::tuple_element<0, my_structure>::type > v;
6279// / \endcode
6380template <std::size_t I, class T >
6481using tuple_element = detail::sequence_tuple::tuple_element<I, decltype( ::boost::pfr::detail::tie_as_tuple(std::declval<T&>()) ) >;
6582
6683
67- // / \brief Type of a field with index `I` in aggregate `T`.
68- // /
69- // / \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
84+ // / \brief Type of a field with index `I` in \aggregate `T`.
7085// /
7186// / \b Example:
7287// / \code
73- // / std::vector< boost::pfr::tuple_element_t<0, my_structure> > v;
88+ // / std::vector< boost::pfr::tuple_element_t<0, my_structure> > v;
7489// / \endcode
7590template <std::size_t I, class T >
7691using tuple_element_t = typename tuple_element<I, T>::type;
7792
7893
79- // / \brief Creates an `std::tuple` from an aggregate T.
80- // /
81- // / \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
94+ // / \brief Creates a `std::tuple` from fields of an \aggregate `val`.
8295// /
8396// / \b Example:
8497// / \code
@@ -96,33 +109,67 @@ constexpr auto structure_to_tuple(const T& val) noexcept {
96109}
97110
98111
99- // / \brief Creates an ` std::tuple` with lvalue references to fields of an aggregate T .
112+ // / \brief std::tie` like function that ties fields of a structure .
100113// /
101- // / \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole} .
114+ // / \returns a `std::tuple` with lvalue and const lvalue references to fields of an \aggregate `val` .
102115// /
103116// / \b Example:
104117// / \code
118+ // / void foo(const int&, const short&);
105119// / struct my_struct { int i, short s; };
120+ // /
121+ // / const my_struct const_s{1, 2};
122+ // / std::apply(foo, structure_tie(const_s));
123+ // /
106124// / my_struct s;
107125// / structure_tie(s) = std::tuple<int, short>{10, 11};
108126// / assert(s.s == 11);
109127// / \endcode
110128template <class T >
111- constexpr auto structure_tie (T& val) noexcept {
129+ constexpr auto structure_tie (const T& val) noexcept {
130+ return detail::make_conststdtiedtuple_from_tietuple (
131+ detail::tie_as_tuple (const_cast <T&>(val)),
132+ detail::make_index_sequence< tuple_size_v<T> >()
133+ );
134+ }
135+
136+
137+ // / \overload structure_tie
138+ template <class T >
139+ constexpr auto structure_tie (T& val
140+ #if !BOOST_PFR_USE_CPP17
141+ , std::enable_if_t <std::is_assignable<T, T>::value>* = nullptr
142+ #endif
143+ ) noexcept {
112144 return detail::make_stdtiedtuple_from_tietuple (
113145 detail::tie_as_tuple (val),
114146 detail::make_index_sequence< tuple_size_v<T> >()
115147 );
116148}
117149
150+ #if !BOOST_PFR_USE_CPP17
151+ // / \overload structure_tie
152+ template <class T >
153+ constexpr auto structure_tie (T&, std::enable_if_t <!std::is_assignable<T, T>::value>* = nullptr ) noexcept {
154+ static_assert (sizeof (T) && false , " ====================> Boost.PFR: Calling boost::pfr::structure_tie on non const non assignable type is allowed only in C++17"
155+ return 0 ;
156+ }
157+ #endif
158+
159+
160+ // / \overload structure_tie
161+ template <class T >
162+ constexpr auto structure_tie (T&&, std::enable_if_t < std::is_rvalue_reference<T&&>::value>* = 0 ) noexcept {
163+ static_assert (sizeof (T) && false , " ====================> Boost.PFR: Calling boost::pfr::structure_tie on rvalue references is forbidden"
164+ return 0 ;
165+ }
166+
118167// / Calls `func` for each field of a `value`.
119168// /
120- // / \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
121- // /
122169// / \param func must have one of the following signatures:
123170// / * any_return_type func(U&& field) // field of value is perfect forwarded to function
124171// / * any_return_type func(U&& field, std::size_t i)
125- // / * any_return_type func(U&& value, I i) // Here I is an `std::integral_constant<size_t, field_index>`
172+ // / * any_return_type func(U&& value, I i) // Here I is an `std::integral_constant<size_t, field_index>`
126173// /
127174// / \param value To each field of this variable will be the `func` applied.
128175// /
@@ -140,7 +187,7 @@ void for_each_field(T&& value, F&& func) {
140187 ::boost::pfr::detail::for_each_field_dispatcher (
141188 value,
142189 [f = std::forward<F>(func)](auto && t) mutable {
143- // MSVC related workaround. It's lambdas do not capture constexprs.
190+ // MSVC related workaround. Its lambdas do not capture constexprs.
144191 constexpr std::size_t fields_count_val_in_lambda
145192 = boost::pfr::detail::fields_count<std::remove_reference_t <T>>();
146193
@@ -155,8 +202,10 @@ void for_each_field(T&& value, F&& func) {
155202 );
156203}
157204
158- // / \brief Create a tuple of lvalue references capable of de-structuring
159- // / assignment from fields of an aggregate T.
205+ // / \brief std::tie-like function that allows assigning to tied values from aggregates.
206+ // /
207+ // / \returns an object with lvalue references to `args...`; on assignment of an \aggregate value to that
208+ // / object each field of an aggregate is assigned to the corresponding `args...` reference.
160209// /
161210// / \b Example:
162211// / \code
@@ -174,4 +223,4 @@ constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Eleme
174223
175224}} // namespace boost::pfr
176225
177- #endif // BOOST_PFR_PRECISE_CORE_HPP
226+ #endif // BOOST_PFR_CORE_HPP
0 commit comments