├── include
    ├── pfr
    │   ├── detail
    │   │   ├── size_t_.hpp
    │   │   ├── core.hpp
    │   │   ├── core_name.hpp
    │   │   ├── config.hpp
    │   │   ├── rvalue_t.hpp
    │   │   ├── stdarray.hpp
    │   │   ├── unsafe_declval.hpp
    │   │   ├── possible_reflectable.hpp
    │   │   ├── tie_from_structure_tuple.hpp
    │   │   ├── core_name14_disabled.hpp
    │   │   ├── for_each_field.hpp
    │   │   ├── fake_object.hpp
    │   │   ├── stdtuple.hpp
    │   │   ├── size_array.hpp
    │   │   ├── for_each_field_impl.hpp
    │   │   ├── io.hpp
    │   │   ├── core17.hpp
    │   │   ├── make_integer_sequence.hpp
    │   │   ├── detectors.hpp
    │   │   ├── make_flat_tuple_of_references.hpp
    │   │   ├── offset_based_getter.hpp
    │   │   ├── sequence_tuple.hpp
    │   │   ├── core14_loophole.hpp
    │   │   ├── functional.hpp
    │   │   ├── core_name20_static.hpp
    │   │   └── fields_count.hpp
    │   ├── traits_fwd.hpp
    │   ├── tuple_size.hpp
    │   ├── traits.hpp
    │   ├── core_name.hpp
    │   ├── io.hpp
    │   ├── functions_for.hpp
    │   ├── ops_fields.hpp
    │   ├── config.hpp
    │   ├── io_fields.hpp
    │   ├── functors.hpp
    │   ├── ops.hpp
    │   └── core.hpp
    └── pfr.hpp
├── example
    ├── motivating_example0.cpp
    ├── get.cpp
    ├── get_name.cpp
    ├── sample_printing.cpp
    └── quick_examples.cpp
├── index.html
├── modules
    ├── usage_test_mu2.cpp
    ├── usage_test_mu1.cpp
    ├── boost_pfr.cppm
    └── usage_sample.cpp
├── LICENSE_1_0.txt
├── CMakeLists.txt
├── doc
    └── Jamfile.v2
├── README.md
└── misc
    ├── generate_cpp17.py
    └── generate_fields_names_big.cpp.py


/include/pfr/detail/size_t_.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_SIZE_T_HPP
 7 | #define PFR_DETAIL_SIZE_T_HPP
 8 | #pragma once
 9 | 
10 | #if !defined(PFR_INTERFACE_UNIT)
11 | #include <type_traits>
12 | #include <cstddef>
13 | #endif
14 | 
15 | namespace pfr { namespace detail {
16 | 
17 | ///////////////////// General utility stuff
18 | template <std::size_t Index>
19 | using size_t_ = std::integral_constant<std::size_t, Index >;
20 | 
21 | }} // namespace pfr::detail
22 | 
23 | #endif // PFR_DETAIL_SIZE_T_HPP
24 | 


--------------------------------------------------------------------------------
/include/pfr.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_HPP
 7 | #define PFR_HPP
 8 | 
 9 | /// \file pfr.hpp
10 | /// Includes all the Boost.PFR headers
11 | 
12 | #include <pfr/config.hpp>
13 | #include <pfr/core.hpp>
14 | #include <pfr/core_name.hpp>
15 | #include <pfr/functions_for.hpp>
16 | #include <pfr/functors.hpp>
17 | #include <pfr/io.hpp>
18 | #include <pfr/io_fields.hpp>
19 | #include <pfr/ops.hpp>
20 | #include <pfr/ops_fields.hpp>
21 | #include <pfr/tuple_size.hpp>
22 | #include <pfr/traits_fwd.hpp>
23 | #include <pfr/traits.hpp>
24 | 
25 | #endif // PFR_HPP
26 | 


--------------------------------------------------------------------------------
/include/pfr/traits_fwd.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2022 Denis Mikhailov
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_TRAITS_FWD_HPP
 7 | #define PFR_DETAIL_TRAITS_FWD_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
13 | 
14 | namespace pfr {
15 | 
16 | PFR_BEGIN_MODULE_EXPORT
17 | 
18 | template<class T, class WhatFor>
19 | struct is_reflectable;
20 | 
21 | PFR_END_MODULE_EXPORT
22 | 
23 | } // namespace pfr
24 | 
25 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
26 | 
27 | #endif // PFR_DETAIL_TRAITS_FWD_HPP
28 | 
29 | 


--------------------------------------------------------------------------------
/example/motivating_example0.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | //[pfr_motivating_example
 8 | #include <iostream>
 9 | #include <string>
10 | 
11 | #include "pfr.hpp"
12 | 
13 | struct some_person {
14 |     std::string name;
15 |     unsigned birth_year;
16 | };
17 | 
18 | int main() {
19 |     some_person val{"Edgar Allan Poe", 1809};
20 | 
21 |     std::cout << pfr::get<0>(val)                // No macro!
22 |         << " was born in " << pfr::get<1>(val);  // Works with any aggregate initializables!
23 | 
24 |     std::cout << pfr::io(val);                   // Outputs: {"Edgar Allan Poe", 1809}
25 | }
26 | //]
27 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_CORE_HPP
 7 | #define PFR_DETAIL_CORE_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | // Each core provides `pfr::detail::tie_as_tuple` and
13 | // `pfr::detail::for_each_field_dispatcher` functions.
14 | //
15 | // The whole PFR library is build on top of those two functions.
16 | #if PFR_USE_CPP17
17 | #   include <pfr/detail/core17.hpp>
18 | #elif PFR_USE_LOOPHOLE
19 | #   include <pfr/detail/core14_loophole.hpp>
20 | #else
21 | #   include <pfr/detail/core14_classic.hpp>
22 | #endif
23 | 
24 | #endif // PFR_DETAIL_CORE_HPP
25 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <!--
 3 |  Copyright (c) 2014-2025 Antony Polukhin
 4 |  antoshkka at gmail dot com
 5 | 
 6 |  Distributed under the Boost Software License,
 7 |  Version 1.0. (See accompanying file LICENSE_1_0.txt
 8 |  or copy at http://boost.org/LICENSE_1_0.txt)
 9 | 
10 | boost-no-inspect
11 | -->
12 | <html>
13 | <head>
14 | <meta charset="utf-8">
15 | <meta http-equiv="refresh" content="0; url=../../doc/html/boost_pfr.html">
16 | <title>Boost.Stacktrace</title>
17 | <style>
18 |   body {
19 |     background: #fff;
20 |     color: #000;
21 |   }
22 |   a {
23 |     color: #00f;
24 |     text-decoration: none;
25 |   }
26 | </style>
27 | </head>
28 | <body>
29 |   <p>
30 |     Automatic redirection failed, please go to
31 |     <a href="../../doc/html/boost_pfr.html">../../doc/html/boost_pfr.html</a>
32 |   </p>
33 |   <p>
34 |     &copy; 2014-2024 Antony Polukhin
35 |   </p>
36 | </body>
37 | </html>
38 | 


--------------------------------------------------------------------------------
/modules/usage_test_mu2.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | // To compile manually use a command like the folowing:
 7 | // clang++ -std=c++20 -fmodule-file=pfr.pcm pfr.pcm usage_sample.cpp
 8 | 
 9 | #include <iostream>
10 | #include <iomanip>
11 | 
12 | import pfr;
13 | 
14 | struct some_person {
15 |     std::string name;
16 |     unsigned birth_year;
17 | };
18 | 
19 | void mu1_act();
20 | 
21 | int main() {
22 |     mu1_act();
23 | 
24 |     some_person val{"Joseph Brodsky", 1940};
25 | 
26 |     std::cout << pfr::get<0>(val)                // No macro!
27 |         << " was born in " << pfr::get<1>(val);  // Works with any aggregate!
28 | 
29 |     std::cout << '\n' << pfr::io(val);
30 |     std::cout << "\n." << pfr::get_name<0, some_person>()
31 |         << '=' << val.name << '\n';
32 | }
33 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core_name.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | // Initial implementation by Bela Schaum, https://github.com/schaumb
 8 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
 9 | //
10 | 
11 | #ifndef PFR_DETAIL_CORE_NAME_HPP
12 | #define PFR_DETAIL_CORE_NAME_HPP
13 | #pragma once
14 | 
15 | #include <pfr/detail/config.hpp>
16 | 
17 | // Each core_name provides `pfr::detail::get_name` and
18 | // `pfr::detail::tie_as_names_tuple` functions.
19 | //
20 | // The whole functional of extracting field's names is build on top of those
21 | // two functions.
22 | #if PFR_CORE_NAME_ENABLED
23 | #include <pfr/detail/core_name20_static.hpp>
24 | #else
25 | #include <pfr/detail/core_name14_disabled.hpp>
26 | #endif
27 | 
28 | #endif // PFR_DETAIL_CORE_NAME_HPP
29 | 
30 | 


--------------------------------------------------------------------------------
/modules/usage_test_mu1.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | // To compile manually use a command like the folowing:
 7 | // clang++ -std=c++20 -fmodule-file=pfr.pcm pfr.pcm usage_sample.cpp
 8 | 
 9 | #include <iostream>
10 | 
11 | #include <pfr.hpp>
12 | 
13 | struct some_person {
14 |     std::string name;
15 |     unsigned birth_year;
16 | };
17 | 
18 | void mu1_act() {
19 |     some_person val{"Edgar Allan Poe", 1809};
20 | 
21 |     std::cout << pfr::get<0>(val)                // No macro!
22 |         << " was born in " << pfr::get<1>(val);  // Works with any aggregate!
23 | 
24 |     std::cout << '\n' << pfr::io(val);           // Outputs: {"Edgar Allan Poe", 1809}
25 |     std::cout << "\n." << pfr::get_name<0, some_person>()
26 |         << '=' << val.name << '\n';                     // Outputs: .name=Edgar Allan Poe
27 | }
28 | 


--------------------------------------------------------------------------------
/modules/boost_pfr.cppm:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | // To compile manually use a command like the folowing:
 7 | // clang++ -I ../include -std=c++20 --precompile -x c++-module pfr.cppm
 8 | 
 9 | module;
10 | 
11 | #include <version>
12 | #include <cstddef>
13 | #include <cstdint>
14 | 
15 | #ifdef PFR_USE_STD_MODULE
16 | import std;
17 | #else
18 | #include <array>
19 | #include <cstddef>
20 | #include <functional>
21 | #include <iomanip>
22 | #include <iostream>
23 | #include <limits>
24 | #include <memory>
25 | #include <string>
26 | #include <string_view>
27 | #include <tuple>
28 | #include <type_traits>
29 | #include <utility>
30 | #include <variant>
31 | #endif
32 | 
33 | #define PFR_INTERFACE_UNIT
34 | 
35 | export module pfr;
36 | 
37 | #ifdef __clang__
38 | #   pragma clang diagnostic ignored "-Winclude-angled-in-module-purview"
39 | #endif
40 | 
41 | #include <pfr.hpp>
42 | 
43 | 


--------------------------------------------------------------------------------
/modules/usage_sample.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | // To compile manually use a command like the folowing:
 7 | // clang++ -std=c++20 -fmodule-file=pfr.pcm pfr.pcm usage_sample.cpp
 8 | 
 9 | //[pfr_module_example
10 | #include <iostream>
11 | #include <iomanip>
12 | #include <string>
13 | 
14 | import pfr;
15 | 
16 | struct some_person {
17 |     std::string name;
18 |     unsigned birth_year;
19 | };
20 | 
21 | int main() {
22 |     some_person val{"Edgar Allan Poe", 1809};
23 | 
24 |     std::cout << pfr::get<0>(val)                // No macro!
25 |         << " was born in " << pfr::get<1>(val);  // Works with any aggregate!
26 | 
27 |     std::cout << '\n' << pfr::io(val);           // Outputs: {"Edgar Allan Poe", 1809}
28 |     std::cout << "\n." << pfr::get_name<0, some_person>()
29 |         << '=' << val.name << '\n';                     // Outputs: .name=Edgar Allan Poe
30 | }
31 | //]
32 | 


--------------------------------------------------------------------------------
/include/pfr/detail/config.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | // Copyright (c) 2022 Denis Mikhailov
 3 | //
 4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | #ifndef PFR_DETAIL_CONFIG_HPP
 8 | #define PFR_DETAIL_CONFIG_HPP
 9 | #pragma once
10 | 
11 | #include <pfr/config.hpp>
12 | 
13 | #if !PFR_ENABLED
14 | 
15 | #error Boost.PFR library is not supported in your environment.             \
16 |        Try one of the possible solutions:                                  \
17 |        1. try to take away an '-DPFR_ENABLED=0', if it exists        \
18 |        2. enable C++14;                                                    \
19 |        3. enable C++17;                                                    \
20 |        4. update your compiler;                                            \
21 |        or disable this error by '-DPFR_ENABLED=1' if you really know what are you doing.
22 | 
23 | #endif // !PFR_ENABLED
24 | 
25 | #endif // PFR_DETAIL_CONFIG_HPP
26 | 
27 | 


--------------------------------------------------------------------------------
/example/get.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright 2016-2025 Antony Polukhin
 2 | 
 3 | // Distributed under the Boost Software License, Version 1.0.
 4 | // (See the accompanying file LICENSE_1_0.txt
 5 | // or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 6 | 
 7 | //[pfr_example_get
 8 | /*`
 9 |     The following example shows how to access structure fields by index using [funcref pfr::get].
10 | 
11 |     Let's define some structure:
12 | */
13 | #include <pfr/core.hpp>
14 | 
15 | struct foo {            // defining structure
16 |     int some_integer;
17 |     char c;
18 | };
19 | 
20 | /*`
21 |     We can access fields of that structure by index:
22 | */
23 | foo f {777, '!'};
24 | auto& r1 = pfr::get<0>(f); // accessing field with index 0, returns reference to `foo::some_integer`
25 | auto& r2 = pfr::get<1>(f); // accessing field with index 1, returns reference to `foo::c`
26 | //] [/pfr_example_get]
27 | 
28 | 
29 | int main() {
30 |     if (r1 != 777) return 1;
31 |     if (r2 != '!') return 2;
32 |     
33 |     r1 = 42;
34 |     r2 = 'A';
35 | 
36 |     if (r1 != 42) return 3;
37 |     if (r2 != 'A') return 4;
38 |     if (f.some_integer != 42) return 5;
39 |     if (f.c != 'A') return 6;
40 | 
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/include/pfr/detail/rvalue_t.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_RVALUE_T_HPP
 7 | #define PFR_DETAIL_RVALUE_T_HPP
 8 | #pragma once
 9 | 
10 | #if !defined(PFR_INTERFACE_UNIT)
11 | #include <type_traits>
12 | #include <utility>      // std::enable_if_t
13 | #endif
14 | 
15 | // This header provides aliases rvalue_t and lvalue_t.
16 | //
17 | // Usage: template <class T> void foo(rvalue<T> rvalue);
18 | //
19 | // Those are useful for
20 | //  * better type safety - you can validate at compile time that only rvalue reference is passed into the function
21 | //  * documentation and readability - rvalue_t<T> is much better than T&&+SFINAE
22 | 
23 | namespace pfr { namespace detail {
24 | 
25 | /// Binds to rvalues only, no copying allowed.
26 | template <class T
27 | #ifdef PFR_DETAIL_STRICT_RVALUE_TESTING
28 |     , class = std::enable_if_t<std::is_rvalue_reference<T&&>::value>
29 | #endif
30 | >
31 | using rvalue_t = T&&;
32 | 
33 | /// Binds to mutable lvalues only
34 | 
35 | }} // namespace pfr::detail
36 | 
37 | #endif // PFR_DETAIL_RVALUE_T_HPP
38 | 


--------------------------------------------------------------------------------
/include/pfr/detail/stdarray.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2023 Denis Mikhailov
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_STDARRAY_HPP
 7 | #define PFR_DETAIL_STDARRAY_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/sequence_tuple.hpp>
13 | 
14 | #if !defined(PFR_INTERFACE_UNIT)
15 | #include <array>
16 | #if PFR_CORE_NAME_ENABLED
17 | #   include <string_view>
18 | #endif
19 | #include <utility> // metaprogramming stuff
20 | #endif
21 | 
22 | namespace pfr { namespace detail {
23 | 
24 | #if PFR_CORE_NAME_ENABLED
25 | template <class T, std::size_t... I>
26 | constexpr auto make_stdarray_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
27 |     return std::array<std::string_view, sizeof...(I)>{
28 |         pfr::detail::sequence_tuple::get<I>(t)...
29 |     };
30 | }
31 | #else
32 | template <class T, std::size_t... I>
33 | constexpr auto make_stdarray_from_tietuple(const T&, std::index_sequence<I...>) noexcept {
34 |     return nullptr;
35 | }
36 | #endif
37 | 
38 | }} // namespace pfr::detail
39 | 
40 | #endif // PFR_DETAIL_STDARRAY_HPP
41 | 
42 | 


--------------------------------------------------------------------------------
/include/pfr/detail/unsafe_declval.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2019-2025 Antony Polukhin.
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_UNSAFE_DECLVAL_HPP
 7 | #define PFR_DETAIL_UNSAFE_DECLVAL_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_INTERFACE_UNIT)
13 | #include <type_traits>
14 | #endif
15 | 
16 | namespace pfr { namespace detail {
17 | 
18 | // This function serves as a link-time assert. If linker requires it, then
19 | // `unsafe_declval()` is used at runtime.
20 | void report_if_you_see_link_error_with_this_function() noexcept;
21 | 
22 | // For returning non default constructible types. Do NOT use at runtime!
23 | //
24 | // GCCs std::declval may not be used in potentionally evaluated contexts,
25 | // so we reinvent it.
26 | template <class T>
27 | constexpr T unsafe_declval() noexcept {
28 |     report_if_you_see_link_error_with_this_function();
29 | 
30 |     typename std::remove_reference<T>::type* ptr = nullptr;
31 |     ptr += 42; // suppresses 'null pointer dereference' warnings
32 |     return static_cast<T>(*ptr);
33 | }
34 | 
35 | }} // namespace pfr::detail
36 | 
37 | 
38 | #endif // PFR_DETAIL_UNSAFE_DECLVAL_HPP
39 | 
40 | 


--------------------------------------------------------------------------------
/example/get_name.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | // Initial implementation by Bela Schaum, https://github.com/schaumb
 8 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
 9 | //
10 | 
11 | #include <pfr/config.hpp>
12 | 
13 | #if PFR_CORE_NAME_ENABLED && PFR_USE_CPP17
14 | //[pfr_example_get_name
15 | /*`
16 |     Since C++20 it's possible to read name of a structure field by index using Boost.PFR library.
17 |     The following example shows how to do it using [funcref pfr::get_name].
18 | 
19 |     Let's define some structure:
20 | */
21 | #include <pfr/core_name.hpp>
22 | 
23 | struct foo {            // defining structure
24 |     int some_integer;
25 |     char c;
26 | };
27 | 
28 | /*`
29 |     We can access field's names of that structure by index:
30 | */
31 | constexpr std::string_view n1 = pfr::get_name<0, foo>(); // returns "some_integer"
32 | constexpr std::string_view n2 = pfr::get_name<1, foo>(); // returns "c"
33 | //] [/pfr_example_get_name]
34 | #endif
35 | 
36 | int main() {
37 | #if PFR_CORE_NAME_ENABLED && PFR_USE_CPP17
38 |     if (n1 != "some_integer") return 1;
39 |     if (n2 != "c") return 2;
40 | #endif
41 | 
42 |     return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/LICENSE_1_0.txt:
--------------------------------------------------------------------------------
 1 | Boost Software License - Version 1.0 - August 17th, 2003
 2 | 
 3 | Permission is hereby granted, free of charge, to any person or organization
 4 | obtaining a copy of the software and accompanying documentation covered by
 5 | this license (the "Software") to use, reproduce, display, distribute,
 6 | execute, and transmit the Software, and to prepare derivative works of the
 7 | Software, and to permit third-parties to whom the Software is furnished to
 8 | do so, all subject to the following:
 9 | 
10 | The copyright notices in the Software and this entire statement, including
11 | the above license grant, this restriction and the following disclaimer,
12 | must be included in all copies of the Software, in whole or in part, and
13 | all derivative works of the Software, unless such copies or derivative
14 | works are solely in the form of machine-executable object code generated by
15 | a source language processor.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 | DEALINGS IN THE SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/include/pfr/detail/possible_reflectable.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2022 Denis Mikhailov
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
 7 | #define PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | #include <pfr/traits_fwd.hpp>
12 | 
13 | #if !defined(PFR_INTERFACE_UNIT)
14 | #include <type_traits> // for std::is_aggregate
15 | #endif
16 | 
17 | namespace pfr { namespace detail {
18 | 
19 | ///////////////////// Returns false when the type exactly wasn't be reflectable
20 | template <class T, class WhatFor>
21 | constexpr decltype(is_reflectable<T, WhatFor>::value) possible_reflectable(long) noexcept {
22 |     return is_reflectable<T, WhatFor>::value;
23 | }
24 | 
25 | #if PFR_ENABLE_IMPLICIT_REFLECTION
26 | 
27 | template <class T, class WhatFor>
28 | constexpr bool possible_reflectable(int) noexcept {
29 | #   if  defined(__cpp_lib_is_aggregate)
30 |     using type = std::remove_cv_t<T>;
31 |     return std::is_aggregate<type>();
32 | #   else
33 |     return true;
34 | #   endif
35 | }
36 | 
37 | #else
38 | 
39 | template <class T, class WhatFor>
40 | constexpr bool possible_reflectable(int) noexcept {
41 |     // negative answer here won't change behaviour in PFR-dependent libraries(like Fusion)
42 |     return false;
43 | }
44 | 
45 | #endif
46 | 
47 | }} // namespace pfr::detail
48 | 
49 | #endif // PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
50 | 
51 | 
52 | 


--------------------------------------------------------------------------------
/include/pfr/detail/tie_from_structure_tuple.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2018 Adam Butcher, Antony Polukhin
 2 | // Copyright (c) 2019-2025 Antony Polukhin
 3 | //
 4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | #ifndef PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
 8 | #define PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
 9 | #pragma once
10 | 
11 | #include <pfr/detail/config.hpp>
12 | 
13 | #include <pfr/detail/core.hpp>
14 | 
15 | #include <pfr/detail/stdtuple.hpp>
16 | #include <pfr/tuple_size.hpp>
17 | #include <pfr/detail/make_integer_sequence.hpp>
18 | 
19 | #if !defined(PFR_INTERFACE_UNIT)
20 | #include <tuple>
21 | #endif
22 | 
23 | namespace pfr { namespace detail {
24 | 
25 | /// \brief A `std::tuple` capable of de-structuring assignment used to support
26 | /// a tie of multiple lvalue references to fields of an aggregate T.
27 | ///
28 | /// \sa pfr::tie_from_structure
29 | template <typename... Elements>
30 | struct tie_from_structure_tuple : std::tuple<Elements&...> {
31 |     using base = std::tuple<Elements&...>;
32 |     using base::base;
33 | 
34 |     template <typename T>
35 |     constexpr tie_from_structure_tuple& operator= (T const& t) {
36 |         base::operator=(
37 |             detail::make_stdtiedtuple_from_tietuple(
38 |                 detail::tie_as_tuple(t),
39 |                 detail::make_index_sequence<tuple_size_v<T>>()));
40 |         return *this;
41 |     }
42 | };
43 | 
44 | }} // namespace pfr::detail
45 | 
46 | #endif // PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
47 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core_name14_disabled.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | // Initial implementation by Bela Schaum, https://github.com/schaumb
 8 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
 9 | //
10 | 
11 | #ifndef PFR_DETAIL_CORE_NAME14_DISABLED_HPP
12 | #define PFR_DETAIL_CORE_NAME14_DISABLED_HPP
13 | #pragma once
14 | 
15 | #include <pfr/detail/config.hpp>
16 | #include <pfr/detail/sequence_tuple.hpp>
17 | 
18 | namespace pfr { namespace detail {
19 | 
20 | template <class T, std::size_t I>
21 | constexpr auto get_name() noexcept {
22 |     static_assert(
23 |         sizeof(T) && false,
24 |         "====================> Boost.PFR: Field's names extracting functionality requires C++20."
25 |     );
26 | 
27 |     return nullptr;
28 | }
29 | 
30 | template <class T>
31 | constexpr auto tie_as_names_tuple() noexcept {
32 |     static_assert(
33 |         sizeof(T) && false,
34 |         "====================> Boost.PFR: Field's names extracting functionality requires C++20."
35 |     );
36 | 
37 |     return detail::sequence_tuple::make_sequence_tuple();
38 | }
39 | 
40 | 
41 | template <class T, class F>
42 | constexpr void for_each_field_with_name(T&& /* value */, F&& /* func */) {
43 |     static_assert(
44 |         sizeof(T) && false,
45 |         "====================> Boost.PFR: Field's names extracting functionality requires C++20."
46 |     );
47 | }
48 | 
49 | }} // namespace pfr::detail
50 | 
51 | #endif // PFR_DETAIL_CORE_NAME14_DISABLED_HPP
52 | 
53 | 


--------------------------------------------------------------------------------
/include/pfr/detail/for_each_field.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_FOR_EACH_FIELD_HPP
 7 | #define PFR_DETAIL_FOR_EACH_FIELD_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/core.hpp>
13 | #include <pfr/detail/fields_count.hpp>
14 | #include <pfr/detail/for_each_field_impl.hpp>
15 | #include <pfr/detail/make_integer_sequence.hpp>
16 | 
17 | #if !defined(PFR_INTERFACE_UNIT)
18 | #include <type_traits>      // metaprogramming stuff
19 | #endif
20 | 
21 | namespace pfr { namespace detail {
22 | 
23 | template <class T, class F>
24 | constexpr void for_each_field(T&& value, F&& func) {
25 |     constexpr std::size_t fields_count_val = pfr::detail::fields_count<std::remove_reference_t<T>>();
26 | 
27 |     ::pfr::detail::for_each_field_dispatcher(
28 |         value,
29 |         [f = std::forward<F>(func)](auto&& t) mutable {
30 |             // MSVC related workaround. Its lambdas do not capture constexprs.
31 |             constexpr std::size_t fields_count_val_in_lambda
32 |                 = pfr::detail::fields_count<std::remove_reference_t<T>>();
33 | 
34 |             ::pfr::detail::for_each_field_impl(
35 |                 t,
36 |                 std::forward<F>(f),
37 |                 detail::make_index_sequence<fields_count_val_in_lambda>{},
38 |                 std::is_rvalue_reference<T&&>{}
39 |             );
40 |         },
41 |         detail::make_index_sequence<fields_count_val>{}
42 |     );
43 | }
44 | 
45 | }} // namespace pfr::detail
46 | 
47 | 
48 | #endif // PFR_DETAIL_FOR_EACH_FIELD_HPP
49 | 


--------------------------------------------------------------------------------
/include/pfr/tuple_size.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | #ifndef PFR_TUPLE_SIZE_HPP
 8 | #define PFR_TUPLE_SIZE_HPP
 9 | #pragma once
10 | 
11 | #include <pfr/detail/config.hpp>
12 | 
13 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
14 | 
15 | #include <pfr/detail/sequence_tuple.hpp>
16 | #include <pfr/detail/fields_count.hpp>
17 | 
18 | #if !defined(PFR_INTERFACE_UNIT)
19 | #include <type_traits>
20 | #include <utility>      // metaprogramming stuff
21 | #endif
22 | 
23 | /// \file pfr/tuple_size.hpp
24 | /// Contains tuple-like interfaces to get fields count \forcedlink{tuple_size}, \forcedlink{tuple_size_v}.
25 | ///
26 | /// \b Synopsis:
27 | namespace pfr {
28 | 
29 | PFR_BEGIN_MODULE_EXPORT
30 | 
31 | /// Has a static const member variable `value` that contains fields count in a T.
32 | /// Works for any T that satisfies \aggregate.
33 | ///
34 | /// \b Example:
35 | /// \code
36 | ///     std::array<int, pfr::tuple_size<my_structure>::value > a;
37 | /// \endcode
38 | template <class T>
39 | using tuple_size = detail::size_t_< pfr::detail::fields_count<T>() >;
40 | 
41 | 
42 | /// `tuple_size_v` is a template variable that contains fields count in a T and
43 | /// works for any T that satisfies \aggregate.
44 | ///
45 | /// \b Example:
46 | /// \code
47 | ///     std::array<int, pfr::tuple_size_v<my_structure> > a;
48 | /// \endcode
49 | template <class T>
50 | constexpr std::size_t tuple_size_v = tuple_size<T>::value;
51 | 
52 | PFR_END_MODULE_EXPORT
53 | 
54 | } // namespace pfr
55 | 
56 | #endif  // #if defined(PFR_USE_MODULES) && !defined(PFR_INTERFACE_UNIT)
57 | 
58 | #endif // PFR_TUPLE_SIZE_HPP
59 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright 2020 Peter Dimov
 2 | # Copyright (c) 2016-2025 Antony Polukhin
 3 | #
 4 | # Distributed under the Boost Software License, Version 1.0.
 5 | # https://www.boost.org/LICENSE_1_0.txt
 6 | 
 7 | cmake_minimum_required(VERSION 3.5...3.31)
 8 | 
 9 | project(pfr VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
10 | 
11 | if (PFR_USE_MODULES)
12 |     add_library(pfr)
13 |     target_sources(pfr PUBLIC
14 |         FILE_SET modules_public TYPE CXX_MODULES FILES modules/boost_pfr.cppm
15 |     )
16 | 
17 |     target_compile_features(pfr PUBLIC cxx_std_20)
18 |     target_compile_definitions(pfr PUBLIC PFR_USE_MODULES)
19 |     if (CMAKE_CXX_COMPILER_IMPORT_STD)
20 |         target_compile_definitions(pfr PRIVATE PFR_USE_STD_MODULE)
21 |         message(STATUS "Using `import std;`")
22 |     else()
23 |         message(STATUS "`import std;` is not available")
24 |     endif()
25 |     target_include_directories(pfr PUBLIC include)
26 | else()
27 |     add_library(pfr INTERFACE)
28 |     target_include_directories(pfr INTERFACE include)
29 | endif()
30 | 
31 | add_library(pfr::pfr ALIAS pfr)
32 | 
33 | enable_testing()
34 | if (BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
35 |     add_subdirectory(test)
36 | endif()
37 | 
38 | if (PFR_USE_MODULES AND BUILD_TESTING)
39 |     add_executable(pfr_module_usage modules/usage_sample.cpp)
40 |     target_link_libraries(pfr_module_usage PRIVATE pfr::pfr)
41 |     add_test(NAME pfr_module_usage COMMAND pfr_module_usage)
42 | 
43 |     # Make sure that mixing includes and imports is fine for different TU
44 |     add_executable(pfr_module_usage_mu modules/usage_test_mu1.cpp modules/usage_test_mu2.cpp)
45 |     target_link_libraries(pfr_module_usage_mu PRIVATE pfr::pfr)
46 |     add_test(NAME pfr_module_usage_mu COMMAND pfr_module_usage_mu)
47 | endif()
48 | 
49 | 


--------------------------------------------------------------------------------
/include/pfr/detail/fake_object.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
 2 | // Copyright (c) 2024-2025 Antony Polukhin
 3 | //
 4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | 
 8 | // Initial implementation by Bela Schaum, https://github.com/schaumb
 9 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
10 | //
11 | 
12 | #ifndef PFR_DETAIL_FAKE_OBJECT_HPP
13 | #define PFR_DETAIL_FAKE_OBJECT_HPP
14 | #pragma once
15 | 
16 | #include <pfr/detail/config.hpp>
17 | 
18 | #ifdef __clang__
19 | #   pragma clang diagnostic push
20 | #   pragma clang diagnostic ignored "-Wundefined-internal"
21 | #   pragma clang diagnostic ignored "-Wundefined-var-template"
22 | #endif
23 | 
24 | namespace pfr { namespace detail {
25 | 
26 | // This class has external linkage while T has not sure.
27 | template <class T>
28 | struct wrapper {
29 |     const T value;
30 | };
31 | 
32 | // This variable servers as a link-time assert.
33 | // If linker requires it, then `fake_object()` is used at runtime.
34 | template <class T>
35 | extern const wrapper<T> do_not_use_PFR_with_local_types;
36 | 
37 | // For returning non default constructible types, it's exclusively used in member name retrieval.
38 | //
39 | // Neither std::declval nor pfr::detail::unsafe_declval are usable there.
40 | // This takes advantage of C++20 features, while pfr::detail::unsafe_declval works
41 | // with the former standards.
42 | template <class T>
43 | constexpr const T& fake_object() noexcept {
44 |     return do_not_use_PFR_with_local_types<T>.value;
45 | }
46 | 
47 | }} // namespace pfr::detail
48 | 
49 | #ifdef __clang__
50 | #   pragma clang diagnostic pop
51 | #endif
52 | 
53 | #endif // PFR_DETAIL_FAKE_OBJECT_HPP
54 | 
55 | 


--------------------------------------------------------------------------------
/include/pfr/detail/stdtuple.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_STDTUPLE_HPP
 7 | #define PFR_DETAIL_STDTUPLE_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/sequence_tuple.hpp>
13 | 
14 | #if !defined(PFR_INTERFACE_UNIT)
15 | #include <utility>      // metaprogramming stuff
16 | #include <tuple>
17 | #endif
18 | 
19 | namespace pfr { namespace detail {
20 | 
21 | template <class T, std::size_t... I>
22 | constexpr auto make_stdtuple_from_tietuple(const T& t, std::index_sequence<I...>) {
23 |     (void)t;  // workaround for MSVC 14.1 `warning C4100: 't': unreferenced formal parameter`
24 |     return std::make_tuple(
25 |         pfr::detail::sequence_tuple::get<I>(t)...
26 |     );
27 | }
28 | 
29 | template <class T, std::size_t... I>
30 | constexpr auto make_stdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
31 |     (void)t;  // workaround for MSVC 14.1 `warning C4100: 't': unreferenced formal parameter`
32 |     return std::tie(
33 |         pfr::detail::sequence_tuple::get<I>(t)...
34 |     );
35 | }
36 | 
37 | template <class T, std::size_t... I>
38 | constexpr auto make_conststdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
39 |     (void)t;  // workaround for MSVC 14.1 `warning C4100: 't': unreferenced formal parameter`
40 |     return std::tuple<
41 |         std::add_lvalue_reference_t<std::add_const_t<
42 |             std::remove_reference_t<decltype(pfr::detail::sequence_tuple::get<I>(t))>
43 |         >>...
44 |     >(
45 |         pfr::detail::sequence_tuple::get<I>(t)...
46 |     );
47 | }
48 | 
49 | }} // namespace pfr::detail
50 | 
51 | #endif // PFR_DETAIL_STDTUPLE_HPP
52 | 


--------------------------------------------------------------------------------
/include/pfr/detail/size_array.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_SIZE_ARRAY_HPP
 7 | #define PFR_DETAIL_SIZE_ARRAY_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_INTERFACE_UNIT)
13 | #include <cstddef>
14 | #endif
15 | 
16 | namespace pfr { namespace detail {
17 | 
18 | ///////////////////// Array that has the constexpr
19 | template <std::size_t N>
20 | struct size_array {                         // libc++ misses constexpr on operator[]
21 |     typedef std::size_t type;
22 |     std::size_t data[N];
23 | 
24 |     static constexpr std::size_t size() noexcept { return N; }
25 | 
26 |     constexpr std::size_t count_nonzeros() const noexcept {
27 |         std::size_t count = 0;
28 |         for (std::size_t i = 0; i < size(); ++i) {
29 |             if (data[i]) {
30 |                 ++ count;
31 |             }
32 |         }
33 |         return count;
34 |     }
35 | 
36 |     constexpr std::size_t count_from_opening_till_matching_parenthis_seq(std::size_t from, std::size_t opening_parenthis, std::size_t closing_parenthis) const noexcept {
37 |         if (data[from] != opening_parenthis) {
38 |             return 0;
39 |         }
40 |         std::size_t unclosed_parnthesis = 0;
41 |         std::size_t count = 0;
42 |         for (; ; ++from) {
43 |             if (data[from] == opening_parenthis) {
44 |                 ++ unclosed_parnthesis;
45 |             } else if (data[from] == closing_parenthis) {
46 |                 -- unclosed_parnthesis;
47 |             }
48 |             ++ count;
49 | 
50 |             if (unclosed_parnthesis == 0) {
51 |                 return count;
52 |             }
53 |         }
54 | 
55 |         return count;
56 |     }
57 | };
58 | 
59 | template <>
60 | struct size_array<0> {                         // libc++ misses constexpr on operator[]
61 |     typedef std::size_t type;
62 |     std::size_t data[1];
63 | 
64 |     static constexpr std::size_t size() noexcept { return 0; }
65 | 
66 |     constexpr std::size_t count_nonzeros() const noexcept {
67 |         return 0;
68 |     }
69 | };
70 | 
71 | template <std::size_t I, std::size_t N>
72 | constexpr std::size_t get(const size_array<N>& a) noexcept {
73 |     static_assert(I < N, "====================> Boost.PFR: Array index out of bounds");
74 |     return a.data[I];
75 | }
76 | 
77 | 
78 | 
79 | }} // namespace pfr::detail
80 | 
81 | #endif // PFR_DETAIL_SIZE_ARRAY_HPP
82 | 


--------------------------------------------------------------------------------
/include/pfr/detail/for_each_field_impl.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
 7 | #define PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/sequence_tuple.hpp>
13 | #include <pfr/detail/rvalue_t.hpp>
14 | 
15 | #if !defined(PFR_INTERFACE_UNIT)
16 | #include <utility>      // metaprogramming stuff
17 | #endif
18 | 
19 | namespace pfr { namespace detail {
20 | 
21 | template <std::size_t Index>
22 | using size_t_ = std::integral_constant<std::size_t, Index >;
23 | 
24 | template <class T, class F, class I, class = decltype(std::declval<F>()(std::declval<T>(), I{}))>
25 | constexpr void for_each_field_impl_apply(T&& v, F&& f, I i, long) {
26 |     std::forward<F>(f)(std::forward<T>(v), i);
27 | }
28 | 
29 | template <class T, class F, class I>
30 | constexpr void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
31 |     std::forward<F>(f)(std::forward<T>(v));
32 | }
33 | 
34 | #if !defined(__cpp_fold_expressions) || __cpp_fold_expressions < 201603
35 | template <class T, class F, std::size_t... I>
36 | constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
37 |      const int v[] = {0, (
38 |          detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
39 |          0
40 |      )...};
41 |      (void)v;
42 | }
43 | 
44 | 
45 | template <class T, class F, std::size_t... I>
46 | constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
47 |      const int v[] = {0, (
48 |          detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
49 |          0
50 |      )...};
51 |      (void)v;
52 | }
53 | #else
54 | template <class T, class F, std::size_t... I>
55 | constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
56 |      (detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L), ...);
57 | }
58 | 
59 | template <class T, class F, std::size_t... I>
60 | constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
61 |      (detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L), ...);
62 | }
63 | #endif
64 | 
65 | }} // namespace pfr::detail
66 | 
67 | 
68 | #endif // PFR_DETAIL_FOR_EACH_FIELD_IMPL_HPP
69 | 


--------------------------------------------------------------------------------
/include/pfr/detail/io.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_IO_HPP
 7 | #define PFR_DETAIL_IO_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/sequence_tuple.hpp>
13 | 
14 | #if !defined(PFR_INTERFACE_UNIT)
15 | #include <iosfwd>       // stream operators
16 | #include <iomanip>
17 | 
18 | #if defined(__has_include)
19 | #   if __has_include(<string_view>) && PFR_USE_CPP17
20 | #       include <string_view>
21 | #   endif
22 | #endif
23 | 
24 | #endif
25 | 
26 | namespace pfr { namespace detail {
27 | 
28 | inline auto quoted_helper(const std::string& s) noexcept {
29 |     return std::quoted(s);
30 | }
31 | 
32 | #if defined(__has_include)
33 | #   if __has_include(<string_view>) && PFR_USE_CPP17
34 | template <class CharT, class Traits>
35 | inline auto quoted_helper(std::basic_string_view<CharT, Traits> s) noexcept {
36 |     return std::quoted(s);
37 | }
38 | #   endif
39 | #endif
40 | 
41 | inline auto quoted_helper(std::string& s) noexcept {
42 |     return std::quoted(s);
43 | }
44 | 
45 | template <class T>
46 | inline decltype(auto) quoted_helper(T&& v) noexcept {
47 |     return std::forward<T>(v);
48 | }
49 | 
50 | template <std::size_t I, std::size_t N>
51 | struct print_impl {
52 |     template <class Stream, class T>
53 |     static void print (Stream& out, const T& value) {
54 |         if (!!I) out << ", ";
55 |         out << detail::quoted_helper(pfr::detail::sequence_tuple::get<I>(value));
56 |         print_impl<I + 1, N>::print(out, value);
57 |     }
58 | };
59 | 
60 | template <std::size_t I>
61 | struct print_impl<I, I> {
62 |     template <class Stream, class T> static void print (Stream&, const T&) noexcept {}
63 | };
64 | 
65 | 
66 | template <std::size_t I, std::size_t N>
67 | struct read_impl {
68 |     template <class Stream, class T>
69 |     static void read (Stream& in, const T& value) {
70 |         char ignore = {};
71 |         if (!!I) {
72 |             in >> ignore;
73 |             if (ignore != ',') in.setstate(Stream::failbit);
74 |             in >> ignore;
75 |             if (ignore != ' ')  in.setstate(Stream::failbit);
76 |         }
77 |         in >> detail::quoted_helper( pfr::detail::sequence_tuple::get<I>(value) );
78 |         read_impl<I + 1, N>::read(in, value);
79 |     }
80 | };
81 | 
82 | template <std::size_t I>
83 | struct read_impl<I, I> {
84 |     template <class Stream, class T> static void read (Stream&, const T&) {}
85 | };
86 | 
87 | }} // namespace pfr::detail
88 | 
89 | #endif // PFR_DETAIL_IO_HPP
90 | 


--------------------------------------------------------------------------------
/example/sample_printing.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright 2016-2025 Antony Polukhin
 2 | 
 3 | // Distributed under the Boost Software License, Version 1.0.
 4 | // (See the accompanying file LICENSE_1_0.txt
 5 | // or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 6 | 
 7 | //[pfr_sample_printing
 8 | /*`
 9 |     The following example shows how to write your own io-manipulator for printing:
10 | */
11 | #include <pfr/ops.hpp>
12 | #include <ostream>
13 | 
14 | namespace my_ns {
15 | 
16 | /// Usage:
17 | ///     struct foo {std::uint8_t a, b;};
18 | ///     ...
19 | ///     std::cout << my_ns::my_io(foo{42, 22});
20 | ///
21 | /// Output: 42, 22
22 | template <class T>
23 | auto my_io(const T& value);
24 | 
25 | namespace detail {
26 |     // Helpers to print individual values
27 |     template <class T>
28 |     void print_each(std::ostream& out, const T& v) { out << v; }
29 |     void print_each(std::ostream& out, std::uint8_t v) { out << static_cast<unsigned>(v); }
30 |     void print_each(std::ostream& out, std::int8_t v) { out << static_cast<int>(v); }
31 | 
32 |     // Structure to keep a reference to value, that will be ostreamed lower
33 |     template <class T>
34 |     struct io_reference {
35 |         const T& value;
36 |     };
37 | 
38 |     // Output each field of io_reference::value
39 |     template <class T>
40 |     std::ostream& operator<<(std::ostream& out, io_reference<T>&& x) {
41 |         const char* sep = "";
42 | 
43 |         pfr::for_each_field(x.value, [&](const auto& v) {
44 |             out << std::exchange(sep, ", ");
45 |             detail::print_each(out, v);
46 |         });
47 |         return out;
48 |     }
49 | }
50 | 
51 | // Definition:
52 | template <class T>
53 | auto my_io(const T& value) {
54 |     return detail::io_reference<T>{value};
55 | }
56 | 
57 | } // namespace my_ns
58 | //] [/pfr_sample_printing]
59 | 
60 | 
61 | #include <iostream>
62 | #include <sstream>
63 | 
64 | int main() {
65 |     struct foo {std::uint8_t a, b;};
66 | 
67 |     std::ostringstream oss;
68 |     oss << my_ns::my_io(foo{42, 22});
69 | 
70 |     if (oss.str() != "42, 22") {
71 |         return 1;
72 |     }
73 | 
74 |     struct two_big_strings {
75 |         std::string first;
76 |         std::string second;
77 |     };
78 | 
79 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
80 |     const char* huge_string = "Some huge string that should not fit into std::string SSO."
81 |         "And by 'huge' I mean really HUGE string with multiple statements and a lot of periods........."
82 |     ;
83 | 
84 |     oss.str({});
85 |     oss << my_ns::my_io(two_big_strings{
86 |         huge_string, huge_string
87 |     });
88 | 
89 |     if (oss.str() != huge_string + std::string(", ") + huge_string) {
90 |         return 2;
91 |     }
92 | #endif
93 | 
94 |     return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/doc/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | # Copyright Antony Polukhin 2016-2019.
 2 | # Use, modification, and distribution are
 3 | # subject to the Boost Software License, Version 1.0. (See accompanying
 4 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | using quickbook ;
 7 | using boostbook ;
 8 | using doxygen ;
 9 | using xsltproc ;
10 | 
11 | import set ;
12 | import doxygen ;
13 | import xsltproc ;
14 | import notfile ;
15 | import path ;
16 | 
17 | project pfr/doc ;
18 | 
19 | #
20 | # Common params for doxygen
21 | #
22 | 
23 | local doxygen_params =
24 |         <doxygen:param>EXTRACT_ALL=NO
25 |         <doxygen:param>HIDE_UNDOC_MEMBERS=YES
26 |         <doxygen:param>EXTRACT_PRIVATE=NO
27 |         <doxygen:param>ENABLE_PREPROCESSING=YES
28 |         <doxygen:param>EXPAND_ONLY_PREDEF=YES
29 |         <doxygen:param>MACRO_EXPANSION=YES
30 |         <doxygen:param>INLINE_SIMPLE_STRUCTS=YES
31 |         <doxygen:param>SORT_MEMBER_DOCS=NO
32 |         <doxygen:param>"ALIASES= \\
33 |             \"forcedlink{1}=\\xmlonly<link linkend='pfr.\\1'>\\endxmlonly pfr::\\1\\xmlonly</link>\\endxmlonly\" \\
34 |             \"podops=\\b See \\b Also : \\xmlonly<link linkend='pfr.tutorial.three_ways_of_getting_operators'>\\endxmlonly 'Three ways of getting operators' \\xmlonly</link>\\endxmlonly\" \\
35 |             \"fnrefl=\\b See \\b Also : \\xmlonly<link linkend='pfr.tutorial.reflection_of_field_name'>\\endxmlonly 'Reflection of field names' \\xmlonly</link>\\endxmlonly\" \\
36 |             \"customio=\\b See \\b Also : \\xmlonly<link linkend='pfr.tutorial.custom_printing_of_aggregates'>\\endxmlonly 'Custom printing of aggregates' \\xmlonly</link>\\endxmlonly for info on how to implement your own manipulator with custom format.\" \\
37 |             \"aggregate=\\xmlonly<link linkend='pfr.limitations_and_configuration'>\\endxmlonly simple aggregate \\xmlonly</link>\\endxmlonly\" \\
38 |         "
39 |         <doxygen:param>"PREDEFINED= \\
40 |             \"PFR_DOXYGEN_INVOKED=1\" \\
41 |         "
42 |     ;
43 | 
44 | doxygen autodoc_pfr
45 |     :
46 |         [ glob ../include/pfr.hpp ]
47 |         [ glob ../include/pfr/*.hpp ]
48 |     :
49 |         $(doxygen_params)
50 |         <xsl:param>"boost.doxygen.reftitle=Reference Section of PFR"
51 |     ;
52 | 
53 | boostbook pfr-doc
54 |     :
55 |         pfr.qbk
56 |     :
57 |         <dependency>autodoc_pfr
58 |         <xsl:param>boost.root=https://www.boost.org/doc/libs/1_81_0
59 |         #<xsl:param>boost.root=../../../.
60 |         <xml:param>html.stylesheet=../../../../doc/src/boostbook.css
61 |     ;
62 | 
63 | ###############################################################################
64 | alias boostdoc
65 |     : pfr-doc/<format>docbook
66 |     :
67 |     :
68 |     : ;
69 | explicit boostdoc ;
70 | alias boostrelease ;
71 | explicit boostrelease ;
72 | 
73 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core17.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | 
 7 | #ifndef PFR_DETAIL_CORE17_HPP
 8 | #define PFR_DETAIL_CORE17_HPP
 9 | #pragma once
10 | 
11 | #include <pfr/detail/core17_generated.hpp>
12 | #include <pfr/detail/fields_count.hpp>
13 | #include <pfr/detail/for_each_field_impl.hpp>
14 | #include <pfr/detail/rvalue_t.hpp>
15 | 
16 | namespace pfr { namespace detail {
17 | 
18 | #ifndef _MSC_VER // MSVC fails to compile the following code, but compiles the structured bindings in core17_generated.hpp
19 | struct do_not_define_std_tuple_size_for_me {
20 |     bool test1 = true;
21 | };
22 | 
23 | template <class T>
24 | constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN pfr/detail/core17.hpp FILE:
25 |     T val{};
26 |     auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN pfr/detail/core17.hpp FILE:
27 | 
28 |     /****************************************************************************
29 |     *
30 |     * It looks like your compiler or Standard Library can not handle C++17
31 |     * structured bindings.
32 |     *
33 |     * Workaround: Define PFR_USE_CPP17 to 0
34 |     * It will disable the C++17 features for Boost.PFR library.
35 |     *
36 |     * Sorry for the inconvenience caused.
37 |     *
38 |     ****************************************************************************/
39 | 
40 |     return a;
41 | }
42 | 
43 | static_assert(
44 |     do_structured_bindings_work<do_not_define_std_tuple_size_for_me>(),
45 |     "====================> Boost.PFR: Your compiler can not handle C++17 structured bindings. Read the above comments for workarounds."
46 | );
47 | #endif // #ifndef _MSC_VER
48 | 
49 | template <class T>
50 | constexpr auto tie_as_tuple(T& val) noexcept {
51 |   static_assert(
52 |     !std::is_union<T>::value,
53 |     "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
54 |   );
55 |   typedef size_t_<pfr::detail::fields_count<T>()> fields_count_tag;
56 |   return pfr::detail::tie_as_tuple(val, fields_count_tag{});
57 | }
58 | 
59 | template <class T, class F, std::size_t... I>
60 | constexpr void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
61 |     static_assert(
62 |         !std::is_union<T>::value,
63 |         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
64 |     );
65 |     std::forward<F>(f)(
66 |         detail::tie_as_tuple(t)
67 |     );
68 | }
69 | 
70 | }} // namespace pfr::detail
71 | 
72 | #endif // PFR_DETAIL_CORE17_HPP
73 | 


--------------------------------------------------------------------------------
/include/pfr/detail/make_integer_sequence.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2018 Sergei Fedorov
 2 | // Copyright (c) 2019-2025 Antony Polukhin
 3 | //
 4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | #ifndef PFR_DETAIL_MAKE_INTEGER_SEQUENCE_HPP
 8 | #define PFR_DETAIL_MAKE_INTEGER_SEQUENCE_HPP
 9 | #pragma once
10 | 
11 | #include <pfr/detail/config.hpp>
12 | 
13 | #if !defined(PFR_INTERFACE_UNIT)
14 | #include <type_traits>
15 | #include <utility>
16 | #include <cstddef>
17 | #endif
18 | 
19 | namespace pfr { namespace detail {
20 | 
21 | #if PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 0
22 | 
23 | #ifdef __has_builtin
24 | #   if __has_builtin(__make_integer_seq)
25 | #       define PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
26 | #   endif
27 | #endif
28 | 
29 | #ifdef PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
30 | 
31 | using std::integer_sequence;
32 | 
33 | // Clang unable to use namespace qualified std::integer_sequence in __make_integer_seq.
34 | template <typename T, T N>
35 | using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
36 | 
37 | #undef PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
38 | 
39 | #else
40 | 
41 | template <typename T, typename U>
42 | struct join_sequences;
43 | 
44 | template <typename T, T... A, T... B>
45 | struct join_sequences<std::integer_sequence<T, A...>, std::integer_sequence<T, B...>> {
46 |     using type = std::integer_sequence<T, A..., B...>;
47 | };
48 | 
49 | template <typename T, T Min, T Max>
50 | struct build_sequence_impl {
51 |     static_assert(Min < Max, "Start of range must be less than its end");
52 |     static constexpr T size = Max - Min;
53 |     using type = typename join_sequences<
54 |             typename build_sequence_impl<T, Min, Min + size / 2>::type,
55 |             typename build_sequence_impl<T, Min + size / 2 + 1, Max>::type
56 |         >::type;
57 | };
58 | 
59 | template <typename T, T V>
60 | struct build_sequence_impl<T, V, V> {
61 |     using type = std::integer_sequence<T, V>;
62 | };
63 | 
64 | template <typename T, std::size_t N>
65 | struct make_integer_sequence_impl : build_sequence_impl<T, 0, N - 1> {};
66 | 
67 | template <typename T>
68 | struct make_integer_sequence_impl<T, 0> {
69 |     using type = std::integer_sequence<T>;
70 | };
71 | 
72 | template <typename T, T N>
73 | using make_integer_sequence = typename make_integer_sequence_impl<T, N>::type;
74 | 
75 | #endif // !defined PFR_USE_MAKE_INTEGER_SEQ_BUILTIN
76 | #else // PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
77 | 
78 | template <typename T, T N>
79 | using make_integer_sequence = std::make_integer_sequence<T, N>;
80 | 
81 | #endif // PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == 1
82 | 
83 | template <std::size_t N>
84 | using make_index_sequence = make_integer_sequence<std::size_t, N>;
85 | 
86 | template <typename... T>
87 | using index_sequence_for = make_index_sequence<sizeof...(T)>;
88 | 
89 | }} // namespace pfr::detail
90 | 
91 | #endif
92 | 
93 | 


--------------------------------------------------------------------------------
/include/pfr/traits.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2022 Denis Mikhailov
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_TRAITS_HPP
 7 | #define PFR_TRAITS_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
13 | 
14 | #include <pfr/detail/possible_reflectable.hpp>
15 | 
16 | #if !defined(PFR_INTERFACE_UNIT)
17 | #include <type_traits>
18 | #endif
19 | 
20 | /// \file pfr/traits.hpp
21 | /// Contains traits \forcedlink{is_reflectable} and \forcedlink{is_implicitly_reflectable} for detecting an ability to reflect type.
22 | ///
23 | /// \b Synopsis:
24 | 
25 | namespace pfr {
26 | 
27 | PFR_BEGIN_MODULE_EXPORT
28 | 
29 | /// Has a static const member variable `value` when it is known that type T can or can't be reflected using Boost.PFR; otherwise, there is no member variable.
30 | /// Every user may (and in some difficult cases - should) specialize is_reflectable on his own.
31 | ///
32 | /// \b Example:
33 | /// \code
34 | ///     namespace pfr {
35 | ///         template<class All> struct is_reflectable<A, All> : std::false_type {};       // 'A' won't be interpreted as reflectable everywhere
36 | ///         template<> struct is_reflectable<B, boost_fusion_tag> : std::false_type {};   // 'B' won't be interpreted as reflectable in only Boost Fusion
37 | ///     }}
38 | /// \endcode
39 | /// \note is_reflectable affects is_implicitly_reflectable, the decision made by is_reflectable is used by is_implicitly_reflectable.
40 | template<class T, class WhatFor>
41 | struct is_reflectable { /*  does not have 'value' because value is unknown */ };
42 | 
43 | // these specs can't be inherited from 'std::integral_constant< bool, pfr::is_reflectable<T, WhatFor>::value >',
44 | // because it will break the sfinae-friendliness
45 | template<class T, class WhatFor>
46 | struct is_reflectable<const T, WhatFor> : pfr::is_reflectable<T, WhatFor> {};
47 | 
48 | template<class T, class WhatFor>
49 | struct is_reflectable<volatile T, WhatFor> : pfr::is_reflectable<T, WhatFor> {};
50 | 
51 | template<class T, class WhatFor>
52 | struct is_reflectable<const volatile T, WhatFor> : pfr::is_reflectable<T, WhatFor> {};
53 | 
54 | /// Checks the input type for the potential to be reflected.
55 | /// Specialize is_reflectable if you disagree with is_implicitly_reflectable's default decision.
56 | template<class T, class WhatFor>
57 | using is_implicitly_reflectable = std::integral_constant< bool, pfr::detail::possible_reflectable<T, WhatFor>(1L) >;
58 | 
59 | /// Checks the input type for the potential to be reflected.
60 | /// Specialize is_reflectable if you disagree with is_implicitly_reflectable_v's default decision.
61 | template<class T, class WhatFor>
62 | constexpr bool is_implicitly_reflectable_v = is_implicitly_reflectable<T, WhatFor>::value;
63 | 
64 | PFR_END_MODULE_EXPORT
65 | 
66 | } // namespace pfr
67 | 
68 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
69 | 
70 | #endif // PFR_TRAITS_HPP
71 | 
72 | 


--------------------------------------------------------------------------------
/include/pfr/detail/detectors.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_DETECTORS_HPP
 7 | #define PFR_DETAIL_DETECTORS_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_INTERFACE_UNIT)
13 | #include <functional>
14 | #include <type_traits>
15 | #endif
16 | 
17 | namespace pfr { namespace detail {
18 | ///////////////////// `value` is true if Detector<Tleft, Tright> does not compile (SFINAE)
19 |     struct can_not_apply{};
20 | 
21 |     template <template <class, class> class Detector, class Tleft, class Tright>
22 |     struct not_applicable {
23 |         static constexpr bool value = std::is_same<
24 |             Detector<Tleft, Tright>,
25 |             can_not_apply
26 |         >::value;
27 |     };
28 | 
29 | ///////////////////// Detectors for different operators
30 |     template <class S, class T> auto comp_eq_detector_msvc_helper(long) -> decltype(std::declval<S>() == std::declval<T>());
31 |     template <class S, class T> can_not_apply comp_eq_detector_msvc_helper(int);
32 |     template <class T1, class T2> using comp_eq_detector = decltype(comp_eq_detector_msvc_helper<T1,T2>(1L));
33 | 
34 |     template <class S, class T> auto comp_ne_detector_msvc_helper(long) -> decltype(std::declval<S>() != std::declval<T>());
35 |     template <class S, class T> can_not_apply comp_ne_detector_msvc_helper(int);
36 |     template <class T1, class T2> using comp_ne_detector = decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
37 | 
38 |     template <class S, class T> auto comp_lt_detector_msvc_helper(long) -> decltype(std::declval<S>() < std::declval<T>());
39 |     template <class S, class T> can_not_apply comp_lt_detector_msvc_helper(int);
40 |     template <class T1, class T2> using comp_lt_detector = decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
41 | 
42 |     template <class S, class T> auto comp_le_detector_msvc_helper(long) -> decltype(std::declval<S>() <= std::declval<T>());
43 |     template <class S, class T> can_not_apply comp_le_detector_msvc_helper(int);
44 |     template <class T1, class T2> using comp_le_detector = decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
45 | 
46 |     template <class S, class T> auto comp_gt_detector_msvc_helper(long) -> decltype(std::declval<S>() > std::declval<T>());
47 |     template <class S, class T> can_not_apply comp_gt_detector_msvc_helper(int);
48 |     template <class T1, class T2> using comp_gt_detector = decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
49 | 
50 |     template <class S, class T> auto comp_ge_detector_msvc_helper(long) -> decltype(std::declval<S>() >= std::declval<T>());
51 |     template <class S, class T> can_not_apply comp_ge_detector_msvc_helper(int);
52 |     template <class T1, class T2> using comp_ge_detector = decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
53 | 
54 | 
55 |     template <class S> auto hash_detector_msvc_helper(long) -> decltype(std::hash<S>{}(std::declval<S>()));
56 |     template <class S> can_not_apply hash_detector_msvc_helper(int);
57 |     template <class T1, class T2> using hash_detector = decltype(hash_detector_msvc_helper<T1,T2>(1L));
58 | 
59 | 
60 |     template <class S, class T> auto ostreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() << std::declval<T>());
61 |     template <class S, class T> can_not_apply ostreamable_detector_msvc_helper(int);
62 |     template <class S, class T> using ostreamable_detector = decltype(ostreamable_detector_msvc_helper<S,T>(1L));
63 | 
64 |     template <class S, class T> auto istreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() >> std::declval<T>());
65 |     template <class S, class T> can_not_apply istreamable_detector_msvc_helper(int);
66 |     template <class S, class T> using istreamable_detector = decltype(istreamable_detector_msvc_helper<S,T>(1L));
67 | 
68 | }} // namespace pfr::detail
69 | 
70 | #endif // PFR_DETAIL_DETECTORS_HPP
71 | 
72 | 
73 | 


--------------------------------------------------------------------------------
/include/pfr/core_name.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | 
  7 | // Initial implementation by Bela Schaum, https://github.com/schaumb
  8 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
  9 | //
 10 | 
 11 | #ifndef PFR_CORE_NAME_HPP
 12 | #define PFR_CORE_NAME_HPP
 13 | #pragma once
 14 | 
 15 | #include <pfr/detail/config.hpp>
 16 | 
 17 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 18 | 
 19 | #include <pfr/detail/core_name.hpp>
 20 | 
 21 | #include <pfr/detail/sequence_tuple.hpp>
 22 | #include <pfr/detail/stdarray.hpp>
 23 | #include <pfr/detail/make_integer_sequence.hpp>
 24 | 
 25 | #include <pfr/tuple_size.hpp>
 26 | 
 27 | #if !defined(PFR_INTERFACE_UNIT)
 28 | #include <cstddef> // for std::size_t
 29 | #endif
 30 | 
 31 | /// \file pfr/core_name.hpp
 32 | /// Contains functions \forcedlink{get_name} and \forcedlink{names_as_array} to know which names each field of any \aggregate has.
 33 | ///
 34 | /// \fnrefl for details.
 35 | ///
 36 | /// \b Synopsis:
 37 | 
 38 | namespace pfr {
 39 | 
 40 | PFR_BEGIN_MODULE_EXPORT
 41 | 
 42 | /// \brief Returns name of a field with index `I` in \aggregate `T`.
 43 | ///
 44 | /// \b Example:
 45 | /// \code
 46 | ///     struct my_struct { int i, short s; };
 47 | ///
 48 | ///     assert(pfr::get_name<0, my_struct>() == "i");
 49 | ///     assert(pfr::get_name<1, my_struct>() == "s");
 50 | /// \endcode
 51 | template <std::size_t I, class T>
 52 | constexpr
 53 | #ifdef PFR_DOXYGEN_INVOKED
 54 | std::string_view
 55 | #else
 56 | auto
 57 | #endif
 58 | get_name() noexcept {
 59 |     return detail::get_name<T, I>();
 60 | }
 61 | 
 62 | // FIXME: implement this
 63 | // template<class U, class T>
 64 | // constexpr auto get_name() noexcept {
 65 | //     return detail::sequence_tuple::get_by_type_impl<U>( detail::tie_as_names_tuple<T>() );
 66 | // }
 67 | 
 68 | /// \brief Creates a `std::array` from names of fields of an \aggregate `T`.
 69 | ///
 70 | /// \b Example:
 71 | /// \code
 72 | ///     struct my_struct { int i, short s; };
 73 | ///     std::array<std::string_view, 2> a = pfr::names_as_array<my_struct>();
 74 | ///     assert(a[0] == "i");
 75 | /// \endcode
 76 | template <class T>
 77 | constexpr
 78 | #ifdef PFR_DOXYGEN_INVOKED
 79 | std::array<std::string_view, pfr::tuple_size_v<T>>
 80 | #else
 81 | auto
 82 | #endif
 83 | names_as_array() noexcept {
 84 |     return detail::make_stdarray_from_tietuple(
 85 |         detail::tie_as_names_tuple<T>(),
 86 |         detail::make_index_sequence< tuple_size_v<T> >()
 87 |     );
 88 | }
 89 | 
 90 | 
 91 | /// Calls `func` for each field with its name of a `value`
 92 | ///
 93 | /// \param func must have one of the following signatures:
 94 | ///     * any_return_type func(std::string_view name, U&& field)                // field of value is perfect forwarded to function
 95 | ///     * any_return_type func(std::string_view name, U&& field, std::size_t i)
 96 | ///     * any_return_type func(std::string_view name, U&& value, I i)           // Here I is an `std::integral_constant<size_t, field_index>`
 97 | ///
 98 | /// \param value To each field of this variable will be the `func` applied.
 99 | ///
100 | /// \b Example:
101 | /// \code
102 | ///     struct Toto { int a; char c; };
103 | ///     Toto t {5, 'c'};
104 | ///     auto print = [](std::string_view name, const auto& value){ std::cout << "Name: " << name << " Value: " << value << std::endl; };
105 | ///     for_each_field_with_name(t, print);
106 | /// \endcode
107 | template <class T, class F>
108 | constexpr void for_each_field_with_name(T&& value, F&& func) {
109 |     return pfr::detail::for_each_field_with_name(std::forward<T>(value), std::forward<F>(func));
110 | }
111 | 
112 | PFR_END_MODULE_EXPORT
113 | 
114 | } // namespace pfr
115 | 
116 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
117 | 
118 | #endif // PFR_CORE_NAME_HPP
119 | 


--------------------------------------------------------------------------------
/include/pfr/io.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_IO_HPP
  7 | #define PFR_IO_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 13 | 
 14 | #include <pfr/detail/detectors.hpp>
 15 | #include <pfr/io_fields.hpp>
 16 | 
 17 | /// \file pfr/io.hpp
 18 | /// Contains IO stream manipulator \forcedlink{io} for types.
 19 | /// If type is streamable using its own operator or its conversion operator, then the types operator is used.
 20 | ///
 21 | /// \b Example:
 22 | /// \code
 23 | ///     #include <pfr/io.hpp>
 24 | ///     struct comparable_struct {      // No operators defined for that structure
 25 | ///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
 26 | ///     };
 27 | ///     // ...
 28 | ///
 29 | ///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
 30 | ///     std::cout << pfr::io(s1);  // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
 31 | /// \endcode
 32 | ///
 33 | /// \podops for other ways to define operators and more details.
 34 | ///
 35 | /// \b Synopsis:
 36 | namespace pfr {
 37 | 
 38 | namespace detail {
 39 | 
 40 | ///////////////////// Helper typedefs
 41 |     template <class Stream, class Type>
 42 |     using enable_not_ostreamable_t = std::enable_if_t<
 43 |         not_applicable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
 44 |         Stream&
 45 |     >;
 46 | 
 47 |     template <class Stream, class Type>
 48 |     using enable_not_istreamable_t = std::enable_if_t<
 49 |         not_applicable<istreamable_detector, Stream&, Type&>::value,
 50 |         Stream&
 51 |     >;
 52 | 
 53 |     template <class Stream, class Type>
 54 |     using enable_ostreamable_t = std::enable_if_t<
 55 |         !not_applicable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
 56 |         Stream&
 57 |     >;
 58 | 
 59 |     template <class Stream, class Type>
 60 |     using enable_istreamable_t = std::enable_if_t<
 61 |         !not_applicable<istreamable_detector, Stream&, Type&>::value,
 62 |         Stream&
 63 |     >;
 64 | 
 65 | ///////////////////// IO impl
 66 | 
 67 | template <class T>
 68 | struct io_impl {
 69 |     T value;
 70 | };
 71 | 
 72 | PFR_BEGIN_MODULE_EXPORT
 73 | 
 74 | template <class Char, class Traits, class T>
 75 | enable_not_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
 76 |     return out << pfr::io_fields(std::forward<T>(x.value));
 77 | }
 78 | 
 79 | template <class Char, class Traits, class T>
 80 | enable_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
 81 |     return out << x.value;
 82 | }
 83 | 
 84 | template <class Char, class Traits, class T>
 85 | enable_not_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
 86 |     return in >> pfr::io_fields(std::forward<T>(x.value));
 87 | }
 88 | 
 89 | template <class Char, class Traits, class T>
 90 | enable_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
 91 |     return in >> x.value;
 92 | }
 93 | 
 94 | PFR_END_MODULE_EXPORT
 95 | 
 96 | } // namespace detail
 97 | 
 98 | PFR_BEGIN_MODULE_EXPORT
 99 | 
100 | /// IO manipulator to read/write \aggregate `value` using its IO stream operators or using \forcedlink{io_fields} if operators are not available.
101 | ///
102 | /// \b Example:
103 | /// \code
104 | ///     struct my_struct { int i; short s; };
105 | ///     my_struct x;
106 | ///     std::stringstream ss;
107 | ///     ss << "{ 12, 13 }";
108 | ///     ss >> pfr::io(x);
109 | ///     assert(x.i == 12);
110 | ///     assert(x.s == 13);
111 | /// \endcode
112 | ///
113 | /// \customio
114 | template <class T>
115 | auto io(T&& value) noexcept {
116 |     return detail::io_impl<T>{std::forward<T>(value)};
117 | }
118 | 
119 | PFR_END_MODULE_EXPORT
120 | 
121 | } // namespace pfr
122 | 
123 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
124 | 
125 | #endif // PFR_IO_HPP
126 | 


--------------------------------------------------------------------------------
/include/pfr/detail/make_flat_tuple_of_references.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
 7 | #define PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #include <pfr/detail/sequence_tuple.hpp>
13 | #include <pfr/detail/rvalue_t.hpp>
14 | #include <pfr/detail/make_integer_sequence.hpp>
15 | 
16 | #if !defined(PFR_INTERFACE_UNIT)
17 | #include <utility>      // metaprogramming stuff
18 | #endif
19 | 
20 | namespace pfr { namespace detail {
21 | 
22 | template <std::size_t Index>
23 | using size_t_ = std::integral_constant<std::size_t, Index >;
24 | 
25 | // Helper: Make a "getter" object corresponding to built-in tuple::get
26 | // For user-defined structures, the getter should be "offset_based_getter"
27 | struct sequence_tuple_getter {
28 |   template <std::size_t idx, typename TupleOfReferences>
29 |   decltype(auto) get(TupleOfReferences&& t, size_t_<idx>) const noexcept {
30 |     return sequence_tuple::get<idx>(std::forward<TupleOfReferences>(t));
31 |   }
32 | };
33 | 
34 | 
35 | template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
36 | constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<Size>) noexcept;
37 | 
38 | template <class TupleOrUserType, class Getter, std::size_t Begin>
39 | constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept;
40 | 
41 | template <class TupleOrUserType, class Getter, std::size_t Begin>
42 | constexpr auto make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<1>) noexcept;
43 | 
44 | template <class... T>
45 | constexpr auto tie_as_tuple_with_references(T&... args) noexcept {
46 |     return sequence_tuple::tuple<T&...>{ args... };
47 | }
48 | 
49 | template <class... T>
50 | constexpr decltype(auto) tie_as_tuple_with_references(detail::sequence_tuple::tuple<T...>& t) noexcept {
51 |     return detail::make_flat_tuple_of_references(t, sequence_tuple_getter{}, size_t_<0>{}, size_t_<sequence_tuple::tuple<T...>::size_v>{});
52 | }
53 | 
54 | template <class... T>
55 | constexpr decltype(auto) tie_as_tuple_with_references(const detail::sequence_tuple::tuple<T...>& t) noexcept {
56 |     return detail::make_flat_tuple_of_references(t, sequence_tuple_getter{}, size_t_<0>{}, size_t_<sequence_tuple::tuple<T...>::size_v>{});
57 | }
58 | 
59 | template <class Tuple1, std::size_t... I1, class Tuple2, std::size_t... I2>
60 | constexpr auto my_tuple_cat_impl(const Tuple1& t1, std::index_sequence<I1...>, const Tuple2& t2, std::index_sequence<I2...>) noexcept {
61 |     return detail::tie_as_tuple_with_references(
62 |         sequence_tuple::get<I1>(t1)...,
63 |         sequence_tuple::get<I2>(t2)...
64 |     );
65 | }
66 | 
67 | template <class Tuple1, class Tuple2>
68 | constexpr auto my_tuple_cat(const Tuple1& t1, const Tuple2& t2) noexcept {
69 |     return detail::my_tuple_cat_impl(
70 |         t1, detail::make_index_sequence< Tuple1::size_v >{},
71 |         t2, detail::make_index_sequence< Tuple2::size_v >{}
72 |     );
73 | }
74 | 
75 | template <class TupleOrUserType, class Getter, std::size_t Begin, std::size_t Size>
76 | constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<Size>) noexcept {
77 |     constexpr std::size_t next_size = Size / 2;
78 |     return detail::my_tuple_cat(
79 |         detail::make_flat_tuple_of_references(t, g, size_t_<Begin>{}, size_t_<next_size>{}),
80 |         detail::make_flat_tuple_of_references(t, g, size_t_<Begin + Size / 2>{}, size_t_<Size - next_size>{})
81 |     );
82 | }
83 | 
84 | template <class TupleOrUserType, class Getter, std::size_t Begin>
85 | constexpr sequence_tuple::tuple<> make_flat_tuple_of_references(TupleOrUserType&, const Getter&, size_t_<Begin>, size_t_<0>) noexcept {
86 |     return {};
87 | }
88 | 
89 | template <class TupleOrUserType, class Getter, std::size_t Begin>
90 | constexpr auto make_flat_tuple_of_references(TupleOrUserType& t, const Getter& g, size_t_<Begin>, size_t_<1>) noexcept {
91 |     return detail::tie_as_tuple_with_references(
92 |         g.get(t, size_t_<Begin>{})
93 |     );
94 | }
95 | 
96 | }} // namespace pfr::detail
97 | 
98 | #endif // PFR_DETAIL_MAKE_FLAT_TUPLE_OF_REFERENCES_HPP
99 | 


--------------------------------------------------------------------------------
/include/pfr/functions_for.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016-2025 Antony Polukhin
 2 | //
 3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PFR_FUNCTIONS_FOR_HPP
 7 | #define PFR_FUNCTIONS_FOR_HPP
 8 | #pragma once
 9 | 
10 | #include <pfr/detail/config.hpp>
11 | 
12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
13 | #include <pfr/ops_fields.hpp>
14 | #include <pfr/io_fields.hpp>
15 | #endif
16 | 
17 | /// \file pfr/functions_for.hpp
18 | /// Contains PFR_FUNCTIONS_FOR macro that defined comparison and stream operators for T along with hash_value function.
19 | /// \b Example:
20 | /// \code
21 | ///     #include <pfr/functions_for.hpp>
22 | ///
23 | ///     namespace my_namespace {
24 | ///         struct my_struct {      // No operators defined for that structure
25 | ///             int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
26 | ///         };
27 | ///         PFR_FUNCTIONS_FOR(my_struct)
28 | ///     }
29 | /// \endcode
30 | ///
31 | /// \podops for other ways to define operators and more details.
32 | ///
33 | /// \b Synopsis:
34 | 
35 | /// \def PFR_FUNCTIONS_FOR(T)
36 | /// Defines comparison and stream operators for T along with hash_value function.
37 | ///
38 | /// \b Example:
39 | /// \code
40 | ///     #include <pfr/functions_for.hpp>
41 | ///     struct comparable_struct {      // No operators defined for that structure
42 | ///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
43 | ///     };
44 | ///     PFR_FUNCTIONS_FOR(comparable_struct)
45 | ///     // ...
46 | ///
47 | ///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
48 | ///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
49 | ///     assert(s1 < s2);
50 | ///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
51 | /// \endcode
52 | ///
53 | /// \podops for other ways to define operators and more details.
54 | ///
55 | /// \b Defines \b following \b for \b T:
56 | /// \code
57 | /// bool operator==(const T& lhs, const T& rhs);
58 | /// bool operator!=(const T& lhs, const T& rhs);
59 | /// bool operator< (const T& lhs, const T& rhs);
60 | /// bool operator> (const T& lhs, const T& rhs);
61 | /// bool operator<=(const T& lhs, const T& rhs);
62 | /// bool operator>=(const T& lhs, const T& rhs);
63 | ///
64 | /// template <class Char, class Traits>
65 | /// std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
66 | ///
67 | /// template <class Char, class Traits>
68 | /// std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
69 | ///
70 | /// // helper function for Boost unordered containers and boost::hash<>.
71 | /// std::size_t hash_value(const T& value);
72 | /// \endcode
73 | 
74 | #define PFR_FUNCTIONS_FOR(T)                                                                                                          \
75 |     PFR_MAYBE_UNUSED inline bool operator==(const T& lhs, const T& rhs) { return ::pfr::eq_fields(lhs, rhs); }                 \
76 |     PFR_MAYBE_UNUSED inline bool operator!=(const T& lhs, const T& rhs) { return ::pfr::ne_fields(lhs, rhs); }                 \
77 |     PFR_MAYBE_UNUSED inline bool operator< (const T& lhs, const T& rhs) { return ::pfr::lt_fields(lhs, rhs); }                 \
78 |     PFR_MAYBE_UNUSED inline bool operator> (const T& lhs, const T& rhs) { return ::pfr::gt_fields(lhs, rhs); }                 \
79 |     PFR_MAYBE_UNUSED inline bool operator<=(const T& lhs, const T& rhs) { return ::pfr::le_fields(lhs, rhs); }                 \
80 |     PFR_MAYBE_UNUSED inline bool operator>=(const T& lhs, const T& rhs) { return ::pfr::ge_fields(lhs, rhs); }                 \
81 |     template <class Char, class Traits>                                                                                                     \
82 |     PFR_MAYBE_UNUSED inline ::std::basic_ostream<Char, Traits>& operator<<(::std::basic_ostream<Char, Traits>& out, const T& value) { \
83 |         return out << ::pfr::io_fields(value);                                                                                       \
84 |     }                                                                                                                                       \
85 |     template <class Char, class Traits>                                                                                                     \
86 |     PFR_MAYBE_UNUSED inline ::std::basic_istream<Char, Traits>& operator>>(::std::basic_istream<Char, Traits>& in, T& value) {        \
87 |         return in >> ::pfr::io_fields(value);                                                                                        \
88 |     }                                                                                                                                       \
89 |     PFR_MAYBE_UNUSED inline std::size_t hash_value(const T& v) {                                                                      \
90 |         return ::pfr::hash_fields(v);                                                                                                \
91 |     }                                                                                                                                       \
92 | /**/
93 | 
94 | #endif // PFR_FUNCTIONS_FOR_HPP
95 | 
96 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # [PFR](https://apolukhin.github.io/pfr_non_boost/)
  2 | 
  3 | This is a C++14 library for very basic reflection that gives you access to structure elements by index and provides other `std::tuple` like methods for user defined types without any macro or boilerplate code.
  4 | 
  5 | [Boost.PFR](https://boost.org/libs/pfr) is a part of the [Boost C++ Libraries](https://github.com/boostorg). However, Boost.PFR is a header only library that does not depend on Boost. You can just copy the content of the "include" folder from the github into your project, and the library will work fine.
  6 | 
  7 | For a version of the library without `boost::` namespace see [PFR](https://github.com/apolukhin/pfr_non_boost).
  8 | 
  9 | ### Test results
 10 | 
 11 | Branches        | Build         | Tests coverage | More info
 12 | ----------------|-------------- | -------------- |-----------
 13 | Develop:        | [![CI](https://github.com/boostorg/pfr/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/pfr/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/0mavmnkdmltcdmqa/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/pfr/branch/develop) | [![Coverage Status](https://coveralls.io/repos/github/apolukhin/magic_get/badge.png?branch=develop)](https://coveralls.io/github/apolukhin/magic_get?branch=develop) | [details...](https://regression.boost.io/develop/developer/pfr.html)
 14 | Master:         | [![CI](https://github.com/boostorg/pfr/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/pfr/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/0mavmnkdmltcdmqa/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/pfr/branch/master) | [![Coverage Status](https://coveralls.io/repos/github/apolukhin/magic_get/badge.png?branch=master)](https://coveralls.io/github/apolukhin/magic_get?branch=master) | [details...](https://regression.boost.io/master/developer/pfr.html)
 15 | 
 16 | [Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html)
 17 | 
 18 | ### Motivating Example #0
 19 | ```c++
 20 | #include <iostream>
 21 | #include <fstream>
 22 | #include <string>
 23 | 
 24 | #include "pfr.hpp"
 25 | 
 26 | struct some_person {
 27 |   std::string name;
 28 |   unsigned birth_year;
 29 | };
 30 | 
 31 | int main(int argc, const char* argv[]) {
 32 |   some_person val{"Edgar Allan Poe", 1809};
 33 | 
 34 |   std::cout << pfr::get<0>(val)                // No macro!
 35 |       << " was born in " << pfr::get<1>(val);  // Works with any aggregate initializables!
 36 | 
 37 |   if (argc > 1) {
 38 |     std::ofstream ofs(argv[1]);
 39 |     ofs << pfr::io(val);                       // File now contains: {"Edgar Allan Poe", 1809}
 40 |   }
 41 | }
 42 | ```
 43 | Outputs:
 44 | ```
 45 | Edgar Allan Poe was born in 1809
 46 | ```
 47 | 
 48 | [Run the above sample](https://godbolt.org/z/PfYsWKb7v)
 49 | 
 50 | 
 51 | ### Motivating Example #1
 52 | ```c++
 53 | #include <iostream>
 54 | #include "pfr.hpp"
 55 | 
 56 | struct my_struct { // no ostream operator defined!
 57 |     int i;
 58 |     char c;
 59 |     double d;
 60 | };
 61 | 
 62 | int main() {
 63 |     my_struct s{100, 'H', 3.141593};
 64 |     std::cout << "my_struct has " << pfr::tuple_size<my_struct>::value
 65 |         << " fields: " << pfr::io(s) << "\n";
 66 | }
 67 | 
 68 | ```
 69 | 
 70 | Outputs:
 71 | ```
 72 | my_struct has 3 fields: {100, H, 3.14159}
 73 | ```
 74 | 
 75 | ### Motivating Example #2
 76 | 
 77 | ```c++
 78 | #include <iostream>
 79 | #include "pfr.hpp"
 80 | 
 81 | struct my_struct { // no ostream operator defined!
 82 |     std::string s;
 83 |     int i;
 84 | };
 85 | 
 86 | int main() {
 87 |     my_struct s{{"Das ist fantastisch!"}, 100};
 88 |     std::cout << "my_struct has " << pfr::tuple_size<my_struct>::value
 89 |         << " fields: " << pfr::io(s) << "\n";
 90 | }
 91 | 
 92 | ```
 93 | 
 94 | Outputs:
 95 | ```
 96 | my_struct has 2 fields: {"Das ist fantastisch!", 100}
 97 | ```
 98 | 
 99 | ### Motivating Example #3
100 | 
101 | ```c++
102 | #include <iostream>
103 | #include <string>
104 | 
105 | #include <boost/config/warning_disable.hpp>
106 | #include <boost/spirit/home/x3.hpp>
107 | #include <boost/fusion/include/adapt_boost_pfr.hpp>
108 | 
109 | #include "pfr/io.hpp"
110 | 
111 | namespace x3 = boost::spirit::x3;
112 | 
113 | struct ast_employee { // No BOOST_FUSION_ADAPT_STRUCT defined
114 |     int age;
115 |     std::string forename;
116 |     std::string surname;
117 |     double salary;
118 | };
119 | 
120 | auto const quoted_string = x3::lexeme['"' >> +(x3::ascii::char_ - '"') >> '"'];
121 | 
122 | x3::rule<class employee, ast_employee> const employee = "employee";
123 | auto const employee_def =
124 |     x3::lit("employee")
125 |     >> '{'
126 |     >>  x3::int_ >> ','
127 |     >>  quoted_string >> ','
128 |     >>  quoted_string >> ','
129 |     >>  x3::double_
130 |     >>  '}'
131 |     ;
132 | BOOST_SPIRIT_DEFINE(employee);
133 | 
134 | int main() {
135 |     std::string str = R"(employee{34, "Chip", "Douglas", 2500.00})";
136 |     ast_employee emp;
137 |     x3::phrase_parse(str.begin(),
138 |                      str.end(),
139 |                      employee,
140 |                      x3::ascii::space,
141 |                      emp);
142 |     std::cout << pfr::io(emp) << std::endl;
143 | }
144 | 
145 | ```
146 | Outputs:
147 | ```
148 | (34 Chip Douglas 2500)
149 | ```
150 | 
151 | 
152 | ### Requirements and Limitations
153 | 
154 | [See docs](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html).
155 | 
156 | ### License
157 | 
158 | Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).
159 | 


--------------------------------------------------------------------------------
/include/pfr/ops_fields.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_OPS_FIELDS_HPP
  7 | #define PFR_OPS_FIELDS_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 13 | 
 14 | #include <pfr/core.hpp>
 15 | #include <pfr/detail/functional.hpp>
 16 | 
 17 | /// \file pfr/ops_fields.hpp
 18 | /// Contains field-by-fields comparison and hash functions.
 19 | ///
 20 | /// \b Example:
 21 | /// \code
 22 | ///     #include <pfr/ops_fields.hpp>
 23 | ///     struct comparable_struct {      // No operators defined for that structure
 24 | ///         int i; short s;
 25 | ///     };
 26 | ///     // ...
 27 | ///
 28 | ///     comparable_struct s1 {0, 1};
 29 | ///     comparable_struct s2 {0, 2};
 30 | ///     assert(pfr::lt_fields(s1, s2));
 31 | /// \endcode
 32 | ///
 33 | /// \podops for other ways to define operators and more details.
 34 | ///
 35 | /// \b Synopsis:
 36 | namespace pfr {
 37 | 
 38 | PFR_BEGIN_MODULE_EXPORT
 39 | 
 40 |     /// Does a field-by-field equality comparison.
 41 |     ///
 42 |     /// \returns `L == R && tuple_size_v<T> == tuple_size_v<U>`, where `L` and
 43 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 44 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 45 |     template <class T, class U>
 46 |     constexpr bool eq_fields(const T& lhs, const U& rhs) noexcept {
 47 |         return detail::binary_visit<detail::equal_impl>(lhs, rhs);
 48 |     }
 49 | 
 50 | 
 51 |     /// Does a field-by-field inequality comparison.
 52 |     ///
 53 |     /// \returns `L != R || tuple_size_v<T> != tuple_size_v<U>`, where `L` and
 54 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 55 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 56 |     template <class T, class U>
 57 |     constexpr bool ne_fields(const T& lhs, const U& rhs) noexcept {
 58 |         return detail::binary_visit<detail::not_equal_impl>(lhs, rhs);
 59 |     }
 60 | 
 61 |     /// Does a field-by-field greter comparison.
 62 |     ///
 63 |     /// \returns `L > R || (L == R && tuple_size_v<T> > tuple_size_v<U>)`, where `L` and
 64 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 65 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 66 |     template <class T, class U>
 67 |     constexpr bool gt_fields(const T& lhs, const U& rhs) noexcept {
 68 |         return detail::binary_visit<detail::greater_impl>(lhs, rhs);
 69 |     }
 70 | 
 71 | 
 72 |     /// Does a field-by-field less comparison.
 73 |     ///
 74 |     /// \returns `L < R || (L == R && tuple_size_v<T> < tuple_size_v<U>)`, where `L` and
 75 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 76 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 77 |     template <class T, class U>
 78 |     constexpr bool lt_fields(const T& lhs, const U& rhs) noexcept {
 79 |         return detail::binary_visit<detail::less_impl>(lhs, rhs);
 80 |     }
 81 | 
 82 | 
 83 |     /// Does a field-by-field greater equal comparison.
 84 |     ///
 85 |     /// \returns `L > R || (L == R && tuple_size_v<T> >= tuple_size_v<U>)`, where `L` and
 86 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 87 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 88 |     template <class T, class U>
 89 |     constexpr bool ge_fields(const T& lhs, const U& rhs) noexcept {
 90 |         return detail::binary_visit<detail::greater_equal_impl>(lhs, rhs);
 91 |     }
 92 | 
 93 | 
 94 |     /// Does a field-by-field less equal comparison.
 95 |     ///
 96 |     /// \returns `L < R || (L == R && tuple_size_v<T> <= tuple_size_v<U>)`, where `L` and
 97 |     /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
 98 |     // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
 99 |     template <class T, class U>
100 |     constexpr bool le_fields(const T& lhs, const U& rhs) noexcept {
101 |         return detail::binary_visit<detail::less_equal_impl>(lhs, rhs);
102 |     }
103 | 
104 | 
105 |     /// Does a field-by-field hashing.
106 |     ///
107 |     /// \returns combined hash of all the fields
108 |     template <class T>
109 |     std::size_t hash_fields(const T& x) {
110 |         constexpr std::size_t fields_count_val = pfr::detail::fields_count<std::remove_reference_t<T>>();
111 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
112 |         return detail::hash_impl<0, fields_count_val>::compute(detail::tie_as_tuple(x));
113 | #else
114 |         std::size_t result = 0;
115 |         ::pfr::detail::for_each_field_dispatcher(
116 |             x,
117 |             [&result](const auto& lhs) {
118 |                 // We can not reuse `fields_count_val` in lambda because compilers had issues with
119 |                 // passing constexpr variables into lambdas. Computing is again is the most portable solution.
120 |                 constexpr std::size_t fields_count_val_lambda = pfr::detail::fields_count<std::remove_reference_t<T>>();
121 |                 result = detail::hash_impl<0, fields_count_val_lambda>::compute(lhs);
122 |             },
123 |             detail::make_index_sequence<fields_count_val>{}
124 |         );
125 | 
126 |         return result;
127 | #endif
128 |     }
129 | 
130 | PFR_END_MODULE_EXPORT
131 | 
132 | } // namespace pfr
133 | 
134 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
135 | 
136 | #endif // PFR_OPS_HPP
137 | 


--------------------------------------------------------------------------------
/include/pfr/config.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | // Copyright (c) 2022 Denis Mikhailov
  3 | //
  4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | 
  7 | #ifndef PFR_CONFIG_HPP
  8 | #define PFR_CONFIG_HPP
  9 | #pragma once
 10 | 
 11 | #if !defined(PFR_USE_MODULES) && (__cplusplus >= 201402L || (defined(_MSC_VER) && defined(_MSVC_LANG) && _MSC_VER > 1900))
 12 | #include <type_traits> // to get non standard platform macro definitions (__GLIBCXX__ for example)
 13 | #elif defined(PFR_USE_MODULES)
 14 | #include <version>
 15 | #endif
 16 | 
 17 | /// \file pfr/config.hpp
 18 | /// Contains all the macros that describe Boost.PFR configuration, like PFR_ENABLED
 19 | ///
 20 | /// \note This header file doesn't require C++14 Standard and supports all C++ compilers, even pre C++14 compilers (C++11, C++03...).
 21 | 
 22 | // Reminder:
 23 | //  * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????)
 24 | //  * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017)
 25 | //  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
 26 | //  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
 27 | 
 28 | #ifdef PFR_NOT_SUPPORTED
 29 | #   error Please, do not set PFR_NOT_SUPPORTED value manually, use '-DPFR_ENABLED=0' instead of it
 30 | #endif
 31 | 
 32 | #if defined(_MSC_VER)
 33 | #   if !defined(_MSVC_LANG) || _MSC_VER <= 1900
 34 | #       define PFR_NOT_SUPPORTED 1
 35 | #   endif
 36 | #elif __cplusplus < 201402L
 37 | #   define PFR_NOT_SUPPORTED 1
 38 | #endif
 39 | 
 40 | #ifndef PFR_USE_LOOPHOLE
 41 | #   if defined(_MSC_VER)
 42 | #       if _MSC_VER >= 1927
 43 | #           define PFR_USE_LOOPHOLE 1
 44 | #       else
 45 | #           define PFR_USE_LOOPHOLE 0
 46 | #       endif
 47 | #   elif defined(__clang_major__) && __clang_major__ >= 8
 48 | #       define PFR_USE_LOOPHOLE 0
 49 | #   else
 50 | #       define PFR_USE_LOOPHOLE 1
 51 | #   endif
 52 | #endif
 53 | 
 54 | #ifndef PFR_USE_CPP17
 55 | #   ifdef __cpp_structured_bindings
 56 | #       define PFR_USE_CPP17 1
 57 | #   elif defined(_MSVC_LANG)
 58 | #       if _MSVC_LANG >= 201703L
 59 | #           define PFR_USE_CPP17 1
 60 | #       else
 61 | #           define PFR_USE_CPP17 0
 62 | #       endif
 63 | #   else
 64 | #       define PFR_USE_CPP17 0
 65 | #   endif
 66 | #endif
 67 | 
 68 | #if (!PFR_USE_CPP17 && !PFR_USE_LOOPHOLE)
 69 | #   if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works
 70 | #      define PFR_NOT_SUPPORTED 1
 71 | #   endif
 72 | #endif
 73 | 
 74 | #ifndef PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
 75 | #   if defined(PFR_USE_MODULES)
 76 | #       define PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
 77 | // Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
 78 | #   elif defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
 79 | #       define PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
 80 | #   elif defined(_MSC_VER)
 81 | #       define PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
 82 | //# elif other known working lib
 83 | #   else
 84 | #       define PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
 85 | #   endif
 86 | #endif
 87 | 
 88 | #ifndef PFR_HAS_GUARANTEED_COPY_ELISION
 89 | #   if  defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928)
 90 | #       define PFR_HAS_GUARANTEED_COPY_ELISION 1
 91 | #   else
 92 | #       define PFR_HAS_GUARANTEED_COPY_ELISION 0
 93 | #   endif
 94 | #endif
 95 | 
 96 | #ifndef PFR_ENABLE_IMPLICIT_REFLECTION
 97 | #   if  defined(__cpp_lib_is_aggregate)
 98 | #       define PFR_ENABLE_IMPLICIT_REFLECTION 1
 99 | #   else
100 | // There is no way to detect potential ability to be reflectable without std::is_aggregare
101 | #       define PFR_ENABLE_IMPLICIT_REFLECTION 0
102 | #   endif
103 | #endif
104 | 
105 | #ifndef PFR_CORE_NAME_ENABLED
106 | #   if  (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))
107 | #       if (defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911) \
108 |          || (defined(__clang_major__) && __clang_major__ >= 12)
109 | #           define PFR_CORE_NAME_ENABLED 1
110 | #       else
111 | #           define PFR_CORE_NAME_ENABLED 0
112 | #       endif
113 | #   else
114 | #       define PFR_CORE_NAME_ENABLED 0
115 | #   endif
116 | #endif
117 | 
118 | 
119 | #ifndef PFR_CORE_NAME_PARSING
120 | #   if defined(_MSC_VER) && !defined(__clang__)
121 | #       define PFR_CORE_NAME_PARSING (sizeof("auto __cdecl pfr::detail::name_of_field_impl<") - 1, sizeof(">(void) noexcept") - 1, backward("->"))
122 | #   elif defined(__clang__)
123 | #       define PFR_CORE_NAME_PARSING (sizeof("auto pfr::detail::name_of_field_impl() [MsvcWorkaround = ") - 1, sizeof("}]") - 1, backward("."))
124 | #   elif defined(__GNUC__)
125 | #       define PFR_CORE_NAME_PARSING (sizeof("consteval auto pfr::detail::name_of_field_impl() [with MsvcWorkaround = ") - 1, sizeof(")]") - 1, backward("::"))
126 | #   else
127 | // Default parser for other platforms... Just skip nothing!
128 | #       define PFR_CORE_NAME_PARSING (0, 0, "")
129 | #   endif
130 | #endif
131 | 
132 | #if defined(__has_cpp_attribute)
133 | #   if __has_cpp_attribute(maybe_unused)
134 | #       define PFR_MAYBE_UNUSED [[maybe_unused]]
135 | #   endif
136 | #endif
137 | 
138 | #ifndef PFR_MAYBE_UNUSED
139 | #   define PFR_MAYBE_UNUSED
140 | #endif
141 | 
142 | #ifndef PFR_ENABLED
143 | #   ifdef PFR_NOT_SUPPORTED
144 | #       define PFR_ENABLED 0
145 | #   else
146 | #       define PFR_ENABLED 1
147 | #   endif
148 | #endif
149 | 
150 | #undef PFR_NOT_SUPPORTED
151 | 
152 | #ifdef PFR_INTERFACE_UNIT
153 | #   define PFR_BEGIN_MODULE_EXPORT export {
154 | #   define PFR_END_MODULE_EXPORT }
155 | #else
156 | #   define PFR_BEGIN_MODULE_EXPORT
157 | #   define PFR_END_MODULE_EXPORT
158 | #endif
159 | 
160 | #if defined(PFR_USE_MODULES) && !defined(PFR_INTERFACE_UNIT)
161 | import pfr;
162 | #endif
163 | 
164 | #endif // PFR_CONFIG_HPP
165 | 


--------------------------------------------------------------------------------
/example/quick_examples.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright 2016-2025 Antony Polukhin
  2 | 
  3 | // Distributed under the Boost Software License, Version 1.0.
  4 | // (See the accompanying file LICENSE_1_0.txt
  5 | // or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
  6 | 
  7 | #include <cassert>
  8 | #include <iostream>
  9 | #include <unordered_set>
 10 | #include <set>
 11 | 
 12 | #include <pfr.hpp>
 13 | #include <boost/type_index.hpp>
 14 | 
 15 | // boost-no-inspect
 16 | void test_examples() {
 17 | 
 18 | #if PFR_USE_CPP17
 19 |   {
 20 | //[pfr_quick_examples_ops
 21 |     // Assert equality.
 22 |     // Note that the equality operator for structure is not defined.
 23 | 
 24 |     struct test {
 25 |         std::string f1;
 26 |         std::string_view f2;
 27 |     };
 28 | 
 29 |     assert(
 30 |         pfr::eq(test{"aaa", "zomg"}, test{"aaa", "zomg"})
 31 |     );
 32 | //]
 33 |   }
 34 | #endif
 35 | 
 36 |   {
 37 | //[pfr_quick_examples_for_each
 38 |     // Increment each field of the variable on 1 and
 39 |     // output the content of the variable.
 40 | 
 41 |     struct test {
 42 |         int f1;
 43 |         long f2;
 44 |     };
 45 | 
 46 |     test var{42, 43};
 47 | 
 48 |     pfr::for_each_field(var, [](auto& field) {
 49 |         field += 1;
 50 |     });
 51 | 
 52 |     // Outputs: {43, 44}
 53 |     std::cout << pfr::io(var);
 54 | //]
 55 |   }
 56 | 
 57 |   {
 58 | //[pfr_quick_examples_for_each_idx
 59 |     // Iterate over fields of a variable and output index and
 60 |     // type of a variable.
 61 | 
 62 |     struct tag0{};
 63 |     struct tag1{};
 64 |     struct sample {
 65 |         tag0 a;
 66 |         tag1 b;
 67 |     };
 68 | 
 69 |     // Outputs:
 70 |     //  0: tag0
 71 |     //  1: tag1
 72 |     pfr::for_each_field(sample{}, [](const auto& field, std::size_t idx) {
 73 |         std::cout << '\n' << idx << ": "
 74 |             << boost::typeindex::type_id_runtime(field);
 75 |     });
 76 | //]
 77 |   }
 78 | 
 79 | 
 80 | // Disabling for MSVC as it gives a hard error on using local types:
 81 | //
 82 | // error C7631:
 83 | // 'pfr::detail::do_not_use_PFR_with_local_types<test_examples::sample>':
 84 | // variable with internal linkage declared but not defined
 85 | #if PFR_CORE_NAME_ENABLED && PFR_USE_CPP17 && !defined(_MSC_VER)
 86 |   {
 87 | //[pfr_quick_examples_for_each_with_name
 88 |     // Print the name and value
 89 |     // of each element of the structure
 90 | 
 91 |     struct test {
 92 |         int n;
 93 |         std::string str;
 94 |     };
 95 | 
 96 |     test var{42, "Hello, World!"};
 97 | 
 98 |     // Outputs:
 99 |     //  n: 42
100 |     //  str: Hello, World!
101 |     pfr::for_each_field_with_name(var,
102 |       [](std::string_view name, const auto& value) {
103 |         std::cout << name << ": " << value << std::endl;
104 |     });
105 | //]
106 |   }
107 | #endif
108 | 
109 |   {
110 | //[pfr_quick_examples_tuple_size
111 |     // Getting fields count of some structure
112 | 
113 |     struct some { int a,b,c,d,e; };
114 | 
115 |     std::cout << "Fields count in structure: "
116 |         << pfr::tuple_size<some>::value  // Outputs: 5
117 |         << '\n';
118 | //]
119 |   }
120 | 
121 |   {
122 | //[pfr_quick_examples_get
123 |     // Get field by index/type and assign new value to that field
124 | 
125 |     struct sample {
126 |         char c;
127 |         float f;
128 |     };
129 | 
130 |     sample var{};
131 |     pfr::get<1>(var) = 42.01f;
132 |     pfr::get<char>(var) = 'A';
133 | 
134 |     std::cout << var.c << var.f; // Outputs: A 42.01
135 | //]
136 |   }
137 | 
138 | // Disabling for MSVC as it gives a hard error on using local types:
139 | //
140 | // error C7631:
141 | // 'pfr::detail::do_not_use_PFR_with_local_types<test_examples::sample>':
142 | // variable with internal linkage declared but not defined
143 | #if PFR_CORE_NAME_ENABLED && PFR_USE_CPP17 && !defined(_MSC_VER)
144 |   {
145 | //[pfr_quick_examples_get_name
146 |     // Get name of field by index
147 | 
148 |     struct sample {
149 |         int f_int;
150 |         long f_long;
151 |     };
152 | 
153 |     std::cout << pfr::get_name<0, sample>()
154 |               << pfr::get_name<1, sample>(); // Outputs: f_int f_long
155 | //]
156 |   }
157 | #endif
158 | 
159 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
160 |   {
161 | //[pfr_quick_examples_structure_to_tuple
162 |     // Getting a std::tuple of values from structures fields
163 | 
164 |     struct foo { int a, b; };
165 |     struct other {
166 |         char c;
167 |         foo nested;
168 |     };
169 | 
170 |     other var{'A', {3, 4}};
171 |     std::tuple<char, foo> t = pfr::structure_to_tuple(var);
172 |     assert(std::get<0>(t) == 'A');
173 |     assert(
174 |         pfr::eq(std::get<1>(t), foo{3, 4})
175 |     );
176 | //]
177 |   }
178 | #endif
179 | 
180 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
181 |   {
182 | //[pfr_quick_examples_structure_tie
183 |     // Getting a std::tuple of references to structure fields
184 | 
185 |     struct foo { int a, b; };
186 |     struct other {
187 |         char c;
188 |         foo f;
189 |     };
190 | 
191 |     other var{'A', {14, 15}};
192 |     std::tuple<char&, foo&> t = pfr::structure_tie(var);
193 |     std::get<1>(t) = foo{1, 2};
194 | 
195 |     std::cout << pfr::io(var.f); // Outputs: {1, 2}
196 | //]
197 |   }
198 | #endif
199 | 
200 | } // void test_examples()
201 | 
202 | //[pfr_quick_examples_functions_for
203 | // Define all the comparison and IO operators for my_structure type along
204 | // with hash_value function.
205 | 
206 | #include <pfr/functions_for.hpp>
207 | 
208 | namespace my_namespace {
209 |     struct my_structure {
210 |         int a,b,c,d,e,f,g;
211 |         // ...
212 |     };
213 |     PFR_FUNCTIONS_FOR(my_structure)
214 | }
215 | //]
216 | 
217 | //[pfr_quick_examples_eq_fields
218 | // Define only the equality and inequality operators for my_eq_ne_structure.
219 | 
220 | #include <pfr/functions_for.hpp>
221 | 
222 | namespace my_namespace {
223 |     struct my_eq_ne_structure {
224 |         float a,b,c,d,e,f,g;
225 |         // ...
226 |     };
227 | 
228 |     inline bool operator==(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
229 |         return pfr::eq_fields(x, y);
230 |     }
231 | 
232 |     inline bool operator!=(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
233 |         return pfr::ne_fields(x, y);
234 |     }
235 | }
236 | //]
237 | 
238 | int main() {
239 |     test_examples();
240 | }
241 | 


--------------------------------------------------------------------------------
/include/pfr/detail/offset_based_getter.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2017-2018 Chris Beck
  2 | // Copyright (c) 2019-2025 Antony Polukhin
  3 | //
  4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | 
  7 | #ifndef PFR_DETAIL_OFFSET_BASED_GETTER_HPP
  8 | #define PFR_DETAIL_OFFSET_BASED_GETTER_HPP
  9 | #pragma once
 10 | 
 11 | #include <pfr/detail/config.hpp>
 12 | 
 13 | #include <pfr/detail/sequence_tuple.hpp>
 14 | #include <pfr/detail/rvalue_t.hpp>
 15 | #include <pfr/detail/size_t_.hpp>
 16 | 
 17 | #if !defined(PFR_INTERFACE_UNIT)
 18 | #include <type_traits>
 19 | #include <utility>
 20 | #include <memory>  // std::addressof
 21 | #endif
 22 | 
 23 | namespace pfr { namespace detail {
 24 | 
 25 | // Our own implementation of std::aligned_storage. On godbolt with MSVC, I have compilation errors
 26 | // using the standard version, it seems the compiler cannot generate default ctor.
 27 | 
 28 | template<std::size_t s, std::size_t a>
 29 | struct internal_aligned_storage {
 30 |    alignas(a) char storage_[s];
 31 | };
 32 | 
 33 | // Metafunction that replaces tuple<T1, T2, T3, ...> with
 34 | // tuple<std::aligned_storage_t<sizeof(T1), alignof(T1)>, std::aligned_storage<sizeof(T2), alignof(T2)>, ...>
 35 | //
 36 | // The point is, the new tuple is "layout compatible" in the sense that members have the same offsets,
 37 | // but this tuple is constexpr constructible.
 38 | 
 39 | template <typename T>
 40 | struct tuple_of_aligned_storage;
 41 | 
 42 | template <typename... Ts>
 43 | struct tuple_of_aligned_storage<sequence_tuple::tuple<Ts...>> {
 44 |   using type = sequence_tuple::tuple<internal_aligned_storage<sizeof(Ts),
 45 | #if defined(__GNUC__) && __GNUC__ < 8 && !defined(__x86_64__) && !defined(__CYGWIN__)
 46 |       // Before GCC-8 the `alignof` was returning the optimal alignment rather than the minimal one.
 47 |       // We have to adjust the alignment because otherwise we get the wrong offset.
 48 |       (alignof(Ts) > 4 ? 4 : alignof(Ts))
 49 | #else
 50 |       alignof(Ts)
 51 | #endif
 52 |   >...>;
 53 | };
 54 | 
 55 | // Note: If pfr has a typelist also, could also have an overload for that here
 56 | 
 57 | template <typename T>
 58 | using tuple_of_aligned_storage_t = typename tuple_of_aligned_storage<T>::type;
 59 | 
 60 | /***
 61 |  * Given a structure type and its sequence of members, we want to build a function
 62 |  * object "getter" that implements a version of `std::get` using offset arithmetic
 63 |  * and reinterpret_cast.
 64 |  *
 65 |  * typename U should be a user-defined struct
 66 |  * typename S should be a sequence_tuple which is layout compatible with U
 67 |  */
 68 | 
 69 | template <typename U, typename S>
 70 | class offset_based_getter {
 71 |   using this_t = offset_based_getter<U, S>;
 72 | 
 73 |   static_assert(sizeof(U) == sizeof(S), "====================> Boost.PFR: Member sequence does not indicate correct size for struct type! Maybe the user-provided type is not a SimpleAggregate?");
 74 |   static_assert(alignof(U) == alignof(S), "====================> Boost.PFR: Member sequence does not indicate correct alignment for struct type!");
 75 | 
 76 |   static_assert(!std::is_const<U>::value, "====================> Boost.PFR: const should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later, this indicates an error within pfr");
 77 |   static_assert(!std::is_reference<U>::value, "====================> Boost.PFR: reference should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later, this indicates an error within pfr");
 78 |   static_assert(!std::is_volatile<U>::value, "====================> Boost.PFR: volatile should be stripped from user-defined type when using offset_based_getter or overload resolution will be ambiguous later. this indicates an error within pfr");
 79 | 
 80 |   // Get type of idx'th member
 81 |   template <std::size_t idx>
 82 |   using index_t = typename sequence_tuple::tuple_element<idx, S>::type;
 83 | 
 84 |   // Get offset of idx'th member
 85 |   // Idea: Layout object has the same offsets as instance of S, so if S and U are layout compatible, then these offset
 86 |   // calculations are correct.
 87 |   template <std::size_t idx>
 88 |   static constexpr std::ptrdiff_t offset() noexcept {
 89 |     constexpr tuple_of_aligned_storage_t<S> layout{};
 90 |     return &sequence_tuple::get<idx>(layout).storage_[0] - &sequence_tuple::get<0>(layout).storage_[0];
 91 |   }
 92 | 
 93 |   // Encapsulates offset arithmetic and reinterpret_cast
 94 |   template <std::size_t idx>
 95 |   static index_t<idx> * get_pointer(U * u) noexcept {
 96 |     return reinterpret_cast<index_t<idx> *>(reinterpret_cast<char *>(u) + this_t::offset<idx>());
 97 |   }
 98 | 
 99 |   template <std::size_t idx>
100 |   static const index_t<idx> * get_pointer(const U * u) noexcept {
101 |     return reinterpret_cast<const index_t<idx> *>(reinterpret_cast<const char *>(u) + this_t::offset<idx>());
102 |   }
103 | 
104 |   template <std::size_t idx>
105 |   static volatile index_t<idx> * get_pointer(volatile U * u) noexcept {
106 |     return reinterpret_cast<volatile index_t<idx> *>(reinterpret_cast<volatile char *>(u) + this_t::offset<idx>());
107 |   }
108 | 
109 |   template <std::size_t idx>
110 |   static const volatile index_t<idx> * get_pointer(const volatile U * u) noexcept {
111 |     return reinterpret_cast<const volatile index_t<idx> *>(reinterpret_cast<const volatile char *>(u) + this_t::offset<idx>());
112 |   }
113 | 
114 | public:
115 |   template <std::size_t idx>
116 |   index_t<idx> & get(U & u, size_t_<idx>) const noexcept {
117 |     return *this_t::get_pointer<idx>(std::addressof(u));
118 |   }
119 | 
120 |   template <std::size_t idx>
121 |   index_t<idx> const & get(U const & u, size_t_<idx>) const noexcept {
122 |     return *this_t::get_pointer<idx>(std::addressof(u));
123 |   }
124 | 
125 |   template <std::size_t idx>
126 |   index_t<idx> volatile & get(U volatile & u, size_t_<idx>) const noexcept {
127 |     return *this_t::get_pointer<idx>(std::addressof(u));
128 |   }
129 | 
130 |   template <std::size_t idx>
131 |   index_t<idx> const volatile & get(U const volatile & u, size_t_<idx>) const noexcept {
132 |     return *this_t::get_pointer<idx>(std::addressof(u));
133 |   }
134 | 
135 |   // rvalues must not be used here, to avoid template instantiation bloats.
136 |   template <std::size_t idx>
137 |   index_t<idx> && get(rvalue_t<U> u, size_t_<idx>) const = delete;
138 | };
139 | 
140 | 
141 | }} // namespace pfr::detail
142 | 
143 | #endif // PFR_DETAIL_OFFSET_LIST_HPP
144 | 


--------------------------------------------------------------------------------
/include/pfr/io_fields.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | 
  7 | #ifndef PFR_IO_FIELDS_HPP
  8 | #define PFR_IO_FIELDS_HPP
  9 | #pragma once
 10 | 
 11 | #include <pfr/detail/config.hpp>
 12 | 
 13 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 14 | 
 15 | #include <pfr/detail/core.hpp>
 16 | #include <pfr/detail/sequence_tuple.hpp>
 17 | #include <pfr/detail/io.hpp>
 18 | #include <pfr/detail/make_integer_sequence.hpp>
 19 | #include <pfr/tuple_size.hpp>
 20 | 
 21 | #if !defined(PFR_INTERFACE_UNIT)
 22 | #include <type_traits>
 23 | #include <utility>      // metaprogramming stuff
 24 | #endif
 25 | 
 26 | /// \file pfr/io_fields.hpp
 27 | /// Contains IO manipulator \forcedlink{io_fields} to read/write any \aggregate field-by-field.
 28 | ///
 29 | /// \b Example:
 30 | /// \code
 31 | ///     struct my_struct {
 32 | ///         int i;
 33 | ///         short s;
 34 | ///     };
 35 | ///
 36 | ///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
 37 | ///         return os << pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
 38 | ///     }
 39 | ///
 40 | ///     std::istream& operator>>(std::istream& is, my_struct& x) {
 41 | ///         return is >> pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
 42 | ///     }
 43 | /// \endcode
 44 | ///
 45 | /// \podops for other ways to define operators and more details.
 46 | ///
 47 | /// \b Synopsis:
 48 | 
 49 | namespace pfr {
 50 | 
 51 | namespace detail {
 52 | 
 53 | template <class T>
 54 | struct io_fields_impl {
 55 |     T value;
 56 | };
 57 | 
 58 | PFR_BEGIN_MODULE_EXPORT
 59 | 
 60 | template <class Char, class Traits, class T>
 61 | std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<const T&>&& x) {
 62 |     const T& value = x.value;
 63 |     constexpr std::size_t fields_count_val = pfr::detail::fields_count<T>();
 64 |     out << '{';
 65 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
 66 |     detail::print_impl<0, fields_count_val>::print(out, detail::tie_as_tuple(value));
 67 | #else
 68 |     ::pfr::detail::for_each_field_dispatcher(
 69 |         value,
 70 |         [&out](const auto& val) {
 71 |             // We can not reuse `fields_count_val` in lambda because compilers had issues with
 72 |             // passing constexpr variables into lambdas. Computing is again is the most portable solution.
 73 |             constexpr std::size_t fields_count_val_lambda = pfr::detail::fields_count<T>();
 74 |             detail::print_impl<0, fields_count_val_lambda>::print(out, val);
 75 |         },
 76 |         detail::make_index_sequence<fields_count_val>{}
 77 |     );
 78 | #endif
 79 |     return out << '}';
 80 | }
 81 | 
 82 | 
 83 | template <class Char, class Traits, class T>
 84 | std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<T>&& x) {
 85 |     return out << io_fields_impl<const std::remove_reference_t<T>&>{x.value};
 86 | }
 87 | 
 88 | template <class Char, class Traits, class T>
 89 | std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T&>&& x) {
 90 |     T& value = x.value;
 91 |     constexpr std::size_t fields_count_val = pfr::detail::fields_count<T>();
 92 | 
 93 |     const auto prev_exceptions = in.exceptions();
 94 |     in.exceptions( typename std::basic_istream<Char, Traits>::iostate(0) );
 95 |     const auto prev_flags = in.flags( typename std::basic_istream<Char, Traits>::fmtflags(0) );
 96 | 
 97 |     char parenthis = {};
 98 |     in >> parenthis;
 99 |     if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
100 | 
101 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
102 |     detail::read_impl<0, fields_count_val>::read(in, detail::tie_as_tuple(value));
103 | #else
104 |     ::pfr::detail::for_each_field_dispatcher(
105 |         value,
106 |         [&in](const auto& val) {
107 |             // We can not reuse `fields_count_val` in lambda because compilers had issues with
108 |             // passing constexpr variables into lambdas. Computing is again is the most portable solution.
109 |             constexpr std::size_t fields_count_val_lambda = pfr::detail::fields_count<T>();
110 |             detail::read_impl<0, fields_count_val_lambda>::read(in, val);
111 |         },
112 |         detail::make_index_sequence<fields_count_val>{}
113 |     );
114 | #endif
115 | 
116 |     in >> parenthis;
117 |     if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
118 | 
119 |     in.flags(prev_flags);
120 |     in.exceptions(prev_exceptions);
121 | 
122 |     return in;
123 | }
124 | 
125 | template <class Char, class Traits, class T>
126 | std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<const T&>&& ) {
127 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a pfr::io_fields wrapped type T with const qualifier.");
128 |     return in;
129 | }
130 | 
131 | template <class Char, class Traits, class T>
132 | std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T>&& ) {
133 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a pfr::io_fields wrapped temporary of type T.");
134 |     return in;
135 | }
136 | 
137 | PFR_END_MODULE_EXPORT
138 | 
139 | } // namespace detail
140 | 
141 | PFR_BEGIN_MODULE_EXPORT
142 | 
143 | /// IO manipulator to read/write \aggregate `value` field-by-field.
144 | ///
145 | /// \b Example:
146 | /// \code
147 | ///     struct my_struct {
148 | ///         int i;
149 | ///         short s;
150 | ///     };
151 | ///
152 | ///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
153 | ///         return os << pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
154 | ///     }
155 | ///
156 | ///     std::istream& operator>>(std::istream& is, my_struct& x) {
157 | ///         return is >> pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
158 | ///     }
159 | /// \endcode
160 | ///
161 | /// Input and output streaming operators for `pfr::io_fields` are symmetric, meaning that you get the original value by streaming it and
162 | /// reading back if each fields streaming operator is symmetric.
163 | ///
164 | /// \customio
165 | template <class T>
166 | auto io_fields(T&& value) noexcept {
167 |     return detail::io_fields_impl<T>{std::forward<T>(value)};
168 | }
169 | 
170 | PFR_END_MODULE_EXPORT
171 | 
172 | } // namespace pfr
173 | 
174 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
175 | 
176 | #endif // PFR_IO_FIELDS_HPP
177 | 


--------------------------------------------------------------------------------
/include/pfr/detail/sequence_tuple.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_DETAIL_SEQUENCE_TUPLE_HPP
  7 | #define PFR_DETAIL_SEQUENCE_TUPLE_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | #include <pfr/detail/make_integer_sequence.hpp>
 12 | 
 13 | #if !defined(PFR_INTERFACE_UNIT)
 14 | #include <utility>      // metaprogramming stuff
 15 | #include <cstddef>      // std::size_t
 16 | #endif
 17 | 
 18 | ///////////////////// Tuple that holds its values in the supplied order
 19 | namespace pfr { namespace detail { namespace sequence_tuple {
 20 | 
 21 | template <std::size_t N, class T>
 22 | struct base_from_member {
 23 |     T value;
 24 | };
 25 | 
 26 | template <class I, class ...Tail>
 27 | struct tuple_base;
 28 | 
 29 | 
 30 | 
 31 | template <std::size_t... I, class ...Tail>
 32 | struct tuple_base< std::index_sequence<I...>, Tail... >
 33 |     : base_from_member<I , Tail>...
 34 | {
 35 |     static constexpr std::size_t size_v = sizeof...(I);
 36 | 
 37 |     // We do not use `noexcept` in the following functions, because if user forget to put one then clang will issue an error:
 38 |     // "error: exception specification of explicitly defaulted default constructor does not match the calculated one".
 39 |     constexpr tuple_base() = default;
 40 |     constexpr tuple_base(tuple_base&&) = default;
 41 |     constexpr tuple_base(const tuple_base&) = default;
 42 | 
 43 |     constexpr tuple_base(Tail... v) noexcept
 44 |         : base_from_member<I, Tail>{ v }...
 45 |     {}
 46 | };
 47 | 
 48 | template <>
 49 | struct tuple_base<std::index_sequence<> > {
 50 |     static constexpr std::size_t size_v = 0;
 51 | };
 52 | 
 53 | template <std::size_t N, class T>
 54 | constexpr T& get_impl(base_from_member<N, T>& t) noexcept {
 55 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 56 |     return t.value;
 57 | }
 58 | 
 59 | template <std::size_t N, class T>
 60 | constexpr const T& get_impl(const base_from_member<N, T>& t) noexcept {
 61 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 62 |     return t.value;
 63 | }
 64 | 
 65 | template <std::size_t N, class T>
 66 | constexpr volatile T& get_impl(volatile base_from_member<N, T>& t) noexcept {
 67 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 68 |     return t.value;
 69 | }
 70 | 
 71 | template <std::size_t N, class T>
 72 | constexpr const volatile T& get_impl(const volatile base_from_member<N, T>& t) noexcept {
 73 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 74 |     return t.value;
 75 | }
 76 | 
 77 | template <std::size_t N, class T>
 78 | constexpr T&& get_impl(base_from_member<N, T>&& t) noexcept {
 79 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 80 |     return std::forward<T>(t.value);
 81 | }
 82 | 
 83 | 
 84 | template <class T, std::size_t N>
 85 | constexpr T& get_by_type_impl(base_from_member<N, T>& t) noexcept {
 86 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 87 |     return t.value;
 88 | }
 89 | 
 90 | template <class T, std::size_t N>
 91 | constexpr const T& get_by_type_impl(const base_from_member<N, T>& t) noexcept {
 92 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 93 |     return t.value;
 94 | }
 95 | 
 96 | template <class T, std::size_t N>
 97 | constexpr volatile T& get_by_type_impl(volatile base_from_member<N, T>& t) noexcept {
 98 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
 99 |     return t.value;
100 | }
101 | 
102 | template <class T, std::size_t N>
103 | constexpr const volatile T& get_by_type_impl(const volatile base_from_member<N, T>& t) noexcept {
104 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
105 |     return t.value;
106 | }
107 | 
108 | template <class T, std::size_t N>
109 | constexpr T&& get_by_type_impl(base_from_member<N, T>&& t) noexcept {
110 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
111 |     return std::forward<T>(t.value);
112 | }
113 | 
114 | template <class T, std::size_t N>
115 | constexpr const T&& get_by_type_impl(const base_from_member<N, T>&& t) noexcept {
116 |     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-core.CallAndMessage)
117 |     return std::forward<T>(t.value);
118 | }
119 | 
120 | 
121 | 
122 | 
123 | template <class ...Values>
124 | struct tuple: tuple_base<
125 |     detail::index_sequence_for<Values...>,
126 |     Values...>
127 | {
128 |     using tuple_base<
129 |         detail::index_sequence_for<Values...>,
130 |         Values...
131 |     >::tuple_base;
132 | 
133 |     constexpr static std::size_t size() noexcept { return sizeof...(Values); }
134 |     constexpr static bool empty() noexcept { return size() == 0; }
135 | };
136 | 
137 | 
138 | template <std::size_t N, class ...T>
139 | constexpr decltype(auto) get(tuple<T...>& t) noexcept {
140 |     static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
141 |     return sequence_tuple::get_impl<N>(t);
142 | }
143 | 
144 | template <std::size_t N, class ...T>
145 | constexpr decltype(auto) get(const tuple<T...>& t) noexcept {
146 |     static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
147 |     return sequence_tuple::get_impl<N>(t);
148 | }
149 | 
150 | template <std::size_t N, class ...T>
151 | constexpr decltype(auto) get(const volatile tuple<T...>& t) noexcept {
152 |     static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
153 |     return sequence_tuple::get_impl<N>(t);
154 | }
155 | 
156 | template <std::size_t N, class ...T>
157 | constexpr decltype(auto) get(volatile tuple<T...>& t) noexcept {
158 |     static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
159 |     return sequence_tuple::get_impl<N>(t);
160 | }
161 | 
162 | template <std::size_t N, class ...T>
163 | constexpr decltype(auto) get(tuple<T...>&& t) noexcept {
164 |     static_assert(N < tuple<T...>::size_v, "====================> Boost.PFR: Tuple index out of bounds");
165 |     return sequence_tuple::get_impl<N>(std::move(t));
166 | }
167 | 
168 | template <std::size_t I, class T>
169 | using tuple_element = std::remove_reference< decltype(
170 |         ::pfr::detail::sequence_tuple::get<I>( std::declval<T>() )
171 |     ) >;
172 | 
173 | template <class... Args>
174 | constexpr auto make_sequence_tuple(Args... args) noexcept {
175 |     return ::pfr::detail::sequence_tuple::tuple<Args...>{ args... };
176 | }
177 | 
178 | }}} // namespace pfr::detail::sequence_tuple
179 | 
180 | #endif // PFR_CORE_HPP
181 | 


--------------------------------------------------------------------------------
/misc/generate_cpp17.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | 
  3 | # Copyright (c) 2016-2025 Antony Polukhin
  4 | # Copyright (c) 2023 Denis Mikhailov
  5 | #
  6 | # Distributed under the Boost Software License, Version 1.0. (See accompanying
  7 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  8 | 
  9 | ############################################################################################################################
 10 | 
 11 | import sys
 12 | import string
 13 | 
 14 | # Skipping some letters that may produce keywords or are hard to read, or shadow template parameters
 15 | ascii_letters = string.ascii_letters.replace("o", "").replace("O", "").replace("i", "").replace("I", "").replace("T", "")
 16 | WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE = 3
 17 | 
 18 | PROLOGUE = """// Copyright (c) 2016-2025 Antony Polukhin
 19 | // Copyright (c) 2023 Denis Mikhailov
 20 | //
 21 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 22 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 23 | 
 24 | 
 25 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 26 | //////////////// THIS HEADER IS AUTO GENERATED BY misc/generate_cpp17.py                                    ////////////////
 27 | //////////////// MODIFY AND RUN THE misc/generate_cpp17.py INSTEAD OF DIRECTLY MODIFYING THE GENERATED FILE ////////////////
 28 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 29 | 
 30 | #ifndef PFR_DETAIL_CORE17_GENERATED_HPP
 31 | #define PFR_DETAIL_CORE17_GENERATED_HPP
 32 | #pragma once
 33 | 
 34 | #include <pfr/detail/config.hpp>
 35 | #if !PFR_USE_CPP17
 36 | #   error C++17 is required for this header.
 37 | #endif
 38 | 
 39 | #include <pfr/detail/sequence_tuple.hpp>
 40 | #include <pfr/detail/size_t_.hpp>
 41 | 
 42 | #if !defined(PFR_INTERFACE_UNIT)
 43 | #include <type_traits> // for std::conditional_t, std::is_reference
 44 | #endif
 45 | 
 46 | namespace pfr { namespace detail {
 47 | 
 48 | template <class... Args>
 49 | constexpr auto make_tuple_of_references(Args&&... args) noexcept {
 50 |   return sequence_tuple::tuple<Args&...>{ args... };
 51 | }
 52 | 
 53 | template<typename T, typename Arg>
 54 | constexpr decltype(auto) add_cv_like(Arg& arg) noexcept {
 55 |     if constexpr (std::is_const<T>::value && std::is_volatile<T>::value) {
 56 |         return const_cast<const volatile Arg&>(arg);
 57 |     }
 58 |     else if constexpr (std::is_const<T>::value) {
 59 |         return const_cast<const Arg&>(arg);
 60 |     }
 61 |     else if constexpr (std::is_volatile<T>::value) {
 62 |         return const_cast<volatile Arg&>(arg);
 63 |     }
 64 |     else {
 65 |         return const_cast<Arg&>(arg);
 66 |     }
 67 | }
 68 | 
 69 | // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78939
 70 | template<typename T, typename Sb, typename Arg>
 71 | constexpr decltype(auto) workaround_cast(Arg& arg) noexcept {
 72 |     using output_arg_t = std::conditional_t<!std::is_reference<Sb>(), decltype(detail::add_cv_like<T>(arg)), Sb>;
 73 |     return const_cast<output_arg_t>(arg);
 74 | }
 75 | 
 76 | template <class T>
 77 | constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
 78 |   return sequence_tuple::tuple<>{};
 79 | }
 80 | 
 81 | template <class T>
 82 | constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = nullptr) noexcept {
 83 |   auto& [a] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
 84 |   return ::pfr::detail::make_tuple_of_references(detail::workaround_cast<T, decltype(a)>(a));
 85 | }
 86 | 
 87 | 
 88 | template <class T>
 89 | constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = nullptr) noexcept {
 90 |   return ::pfr::detail::make_tuple_of_references( val );
 91 | }
 92 | 
 93 | """
 94 | 
 95 | ############################################################################################################################
 96 | EPILOGUE = """
 97 | template <class T, std::size_t I>
 98 | constexpr void tie_as_tuple(T& /*val*/, size_t_<I>) noexcept {
 99 |   static_assert(sizeof(T) && false,
100 |                 "====================> Boost.PFR: Too many fields in a structure T. Regenerate include/pfr/detail/core17_generated.hpp file for appropriate count of fields. For example: `python ./misc/generate_cpp17.py 300 > include/pfr/detail/core17_generated.hpp`");
101 | }
102 | 
103 | }} // namespace pfr::detail
104 | 
105 | #endif // PFR_DETAIL_CORE17_GENERATED_HPP
106 | """
107 | 
108 | ############################################################################################################################
109 | 
110 | def fold_workaround_cast(indexes, divider):
111 |     WORKAROUND_CAST_TEMPLATE = """
112 | detail::workaround_cast<T, decltype({arg})>({arg})
113 | """
114 |     lines = []
115 |     div = ''
116 |     tokens = [x.strip() for x in indexes.split(',')]
117 |     casts = [WORKAROUND_CAST_TEMPLATE.strip().format(arg=tok)
118 |              for tok in tokens]
119 |     for i in range(0, len(casts)):
120 |         if i%WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE==0:
121 |             div = ''
122 |             lines.append('')
123 |         lines[-1] += div + casts[i]
124 |         div = ','
125 |     return divider.join(lines)
126 | 
127 | def calc_indexes_count(indexes):
128 |     tokens = [x.strip() for x in indexes.split(',')]
129 |     return len(tokens)
130 | 
131 | class EmptyLinePrinter:
132 |     def print_once(self):
133 |         if not self.printed:
134 |             print("")
135 |             self.printed = True
136 |     printed = False
137 | 
138 | indexes = "    a"
139 | print(PROLOGUE)
140 | funcs_count = 200 if len(sys.argv) == 1 else int(sys.argv[1])
141 | max_args_on_a_line = len(ascii_letters)
142 | for i in range(1, funcs_count):
143 |     if i % max_args_on_a_line == 0:
144 |         indexes += ",\n    "
145 |     else:
146 |         indexes += ","
147 | 
148 |     if i >= max_args_on_a_line:
149 |         indexes += ascii_letters[i // max_args_on_a_line - 1]
150 |     indexes += ascii_letters[i % max_args_on_a_line]
151 | 
152 |     printed_casts = fold_workaround_cast(indexes.strip(), ",\n    ")
153 |     indexes_count = calc_indexes_count(indexes.strip())
154 |     empty_printer = EmptyLinePrinter()
155 | 
156 |     print("template <class T>")
157 |     print("constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + ">) noexcept {")
158 |     if i < max_args_on_a_line:
159 |         print("  auto& [" + indexes.strip() + "] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
160 |     else:
161 |         print("  auto& [")
162 |         print(indexes)
163 |         print("  ] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
164 |         empty_printer.print_once()
165 |  
166 |     if indexes_count < WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE:
167 |         print("  return ::pfr::detail::make_tuple_of_references(" + printed_casts + ");")
168 |     else:
169 |         empty_printer.print_once()
170 |         print("  return ::pfr::detail::make_tuple_of_references(")
171 |         print("    " + printed_casts)
172 |         print("  );")
173 | 
174 |     print("}\n")
175 | 
176 | print(EPILOGUE)
177 | 


--------------------------------------------------------------------------------
/include/pfr/functors.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_FUNCTORS_HPP
  7 | #define PFR_FUNCTORS_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 13 | 
 14 | #include <pfr/ops.hpp>
 15 | 
 16 | #include <pfr/detail/functional.hpp>
 17 | 
 18 | /// \file pfr/functors.hpp
 19 | /// Contains functors that are close to the Standard Library ones.
 20 | /// Each functor calls corresponding Boost.PFR function from pfr/ops.hpp
 21 | ///
 22 | /// \b Example:
 23 | /// \code
 24 | ///     #include <pfr/functors.hpp>
 25 | ///     struct my_struct {      // No operators defined for that structure
 26 | ///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
 27 | ///     };
 28 | ///     // ...
 29 | ///
 30 | ///     std::unordered_set<
 31 | ///         my_struct,
 32 | ///         pfr::hash<>,
 33 | ///         pfr::equal_to<>
 34 | ///     > my_set;
 35 | /// \endcode
 36 | ///
 37 | /// \b Synopsis:
 38 | namespace pfr {
 39 | 
 40 | PFR_BEGIN_MODULE_EXPORT
 41 | 
 42 | ///////////////////// Comparisons
 43 | 
 44 | /// \brief std::equal_to like comparator that returns \forcedlink{eq}(x, y)
 45 | template <class T = void> struct equal_to {
 46 |     /// \return \b true if each field of \b x equals the field with same index of \b y.
 47 |     bool operator()(const T& x, const T& y) const {
 48 |         return pfr::eq(x, y);
 49 |     }
 50 | 
 51 | #ifdef PFR_DOXYGEN_INVOKED
 52 |     /// This typedef exists only if T \b is void
 53 |     typedef std::true_type is_transparent;
 54 | 
 55 |     /// This operator allows comparison of \b x and \b y that have different type.
 56 |     /// \pre Exists only if T \b is void.
 57 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
 58 | #endif
 59 | };
 60 | 
 61 | /// @cond
 62 | template <> struct equal_to<void> {
 63 |     template <class T, class U>
 64 |     bool operator()(const T& x, const U& y) const {
 65 |         return pfr::eq(x, y);
 66 |     }
 67 | 
 68 |     typedef std::true_type is_transparent;
 69 | };
 70 | /// @endcond
 71 | 
 72 | /// \brief std::not_equal like comparator that returns \forcedlink{ne}(x, y)
 73 | template <class T = void> struct not_equal {
 74 |     /// \return \b true if at least one field \b x not equals the field with same index of \b y.
 75 |     bool operator()(const T& x, const T& y) const {
 76 |         return pfr::ne(x, y);
 77 |     }
 78 | 
 79 | #ifdef PFR_DOXYGEN_INVOKED
 80 |     /// This typedef exists only if T \b is void
 81 |     typedef std::true_type is_transparent;
 82 | 
 83 |     /// This operator allows comparison of \b x and \b y that have different type.
 84 |     /// \pre Exists only if T \b is void.
 85 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
 86 | #endif
 87 | };
 88 | 
 89 | /// @cond
 90 | template <> struct not_equal<void> {
 91 |     template <class T, class U>
 92 |     bool operator()(const T& x, const U& y) const {
 93 |         return pfr::ne(x, y);
 94 |     }
 95 | 
 96 |     typedef std::true_type is_transparent;
 97 | };
 98 | /// @endcond
 99 | 
100 | /// \brief std::greater like comparator that returns \forcedlink{gt}(x, y)
101 | template <class T = void> struct greater {
102 |     /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
103 |     bool operator()(const T& x, const T& y) const {
104 |         return pfr::gt(x, y);
105 |     }
106 | 
107 | #ifdef PFR_DOXYGEN_INVOKED
108 |     /// This typedef exists only if T \b is void
109 |     typedef std::true_type is_transparent;
110 | 
111 |     /// This operator allows comparison of \b x and \b y that have different type.
112 |     /// \pre Exists only if T \b is void.
113 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
114 | #endif
115 | };
116 | 
117 | /// @cond
118 | template <> struct greater<void> {
119 |     template <class T, class U>
120 |     bool operator()(const T& x, const U& y) const {
121 |         return pfr::gt(x, y);
122 |     }
123 | 
124 |     typedef std::true_type is_transparent;
125 | };
126 | /// @endcond
127 | 
128 | /// \brief std::less like comparator that returns \forcedlink{lt}(x, y)
129 | template <class T = void> struct less {
130 |     /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
131 |     bool operator()(const T& x, const T& y) const {
132 |         return pfr::lt(x, y);
133 |     }
134 | 
135 | #ifdef PFR_DOXYGEN_INVOKED
136 |     /// This typedef exists only if T \b is void
137 |     typedef std::true_type is_transparent;
138 | 
139 |     /// This operator allows comparison of \b x and \b y that have different type.
140 |     /// \pre Exists only if T \b is void.
141 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
142 | #endif
143 | };
144 | 
145 | /// @cond
146 | template <> struct less<void> {
147 |     template <class T, class U>
148 |     bool operator()(const T& x, const U& y) const {
149 |         return pfr::lt(x, y);
150 |     }
151 | 
152 |     typedef std::true_type is_transparent;
153 | };
154 | /// @endcond
155 | 
156 | /// \brief std::greater_equal like comparator that returns \forcedlink{ge}(x, y)
157 | template <class T = void> struct greater_equal {
158 |     /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
159 |     /// or if each field of \b x equals the field with same index of \b y.
160 |     bool operator()(const T& x, const T& y) const {
161 |         return pfr::ge(x, y);
162 |     }
163 | 
164 | #ifdef PFR_DOXYGEN_INVOKED
165 |     /// This typedef exists only if T \b is void
166 |     typedef std::true_type is_transparent;
167 | 
168 |     /// This operator allows comparison of \b x and \b y that have different type.
169 |     /// \pre Exists only if T \b is void.
170 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
171 | #endif
172 | };
173 | 
174 | /// @cond
175 | template <> struct greater_equal<void> {
176 |     template <class T, class U>
177 |     bool operator()(const T& x, const U& y) const {
178 |         return pfr::ge(x, y);
179 |     }
180 | 
181 |     typedef std::true_type is_transparent;
182 | };
183 | /// @endcond
184 | 
185 | /// \brief std::less_equal like comparator that returns \forcedlink{le}(x, y)
186 | template <class T = void> struct less_equal {
187 |     /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
188 |     /// or if each field of \b x equals the field with same index of \b y.
189 |     bool operator()(const T& x, const T& y) const {
190 |         return pfr::le(x, y);
191 |     }
192 | 
193 | #ifdef PFR_DOXYGEN_INVOKED
194 |     /// This typedef exists only if T \b is void
195 |     typedef std::true_type is_transparent;
196 | 
197 |     /// This operator allows comparison of \b x and \b y that have different type.
198 |     /// \pre Exists only if T \b is void.
199 |     template <class V, class U> bool operator()(const V& x, const U& y) const;
200 | #endif
201 | };
202 | 
203 | /// @cond
204 | template <> struct less_equal<void> {
205 |     template <class T, class U>
206 |     bool operator()(const T& x, const U& y) const {
207 |         return pfr::le(x, y);
208 |     }
209 | 
210 |     typedef std::true_type is_transparent;
211 | };
212 | /// @endcond
213 | 
214 | 
215 | /// \brief std::hash like functor that returns \forcedlink{hash_value}(x)
216 | template <class T> struct hash {
217 |     /// \return hash value of \b x.
218 |     std::size_t operator()(const T& x) const {
219 |         return pfr::hash_value(x);
220 |     }
221 | };
222 | 
223 | PFR_END_MODULE_EXPORT
224 | 
225 | } // namespace pfr
226 | 
227 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
228 | 
229 | #endif // PFR_FUNCTORS_HPP
230 | 


--------------------------------------------------------------------------------
/include/pfr/ops.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_OPS_HPP
  7 | #define PFR_OPS_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 13 | 
 14 | #include <pfr/detail/detectors.hpp>
 15 | #include <pfr/ops_fields.hpp>
 16 | 
 17 | /// \file pfr/ops.hpp
 18 | /// Contains comparison and hashing functions.
 19 | /// If type is comparable using its own operator or its conversion operator, then the types operator is used. Otherwise
 20 | /// the operation is done via corresponding function from pfr/ops.hpp header.
 21 | ///
 22 | /// \b Example:
 23 | /// \code
 24 | ///     #include <pfr/ops.hpp>
 25 | ///     struct comparable_struct {      // No operators defined for that structure
 26 | ///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
 27 | ///     };
 28 | ///     // ...
 29 | ///
 30 | ///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
 31 | ///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
 32 | ///     assert(pfr::lt(s1, s2));
 33 | /// \endcode
 34 | ///
 35 | /// \podops for other ways to define operators and more details.
 36 | ///
 37 | /// \b Synopsis:
 38 | namespace pfr {
 39 | 
 40 | namespace detail {
 41 | 
 42 | ///////////////////// Helper typedefs that are used by all the ops
 43 |     template <template <class, class> class Detector, class T, class U>
 44 |     using enable_not_comp_base_t = std::enable_if_t<
 45 |         not_applicable<Detector, T const&, U const&>::value,
 46 |         bool
 47 |     >;
 48 | 
 49 |     template <template <class, class> class Detector, class T, class U>
 50 |     using enable_comp_base_t = std::enable_if_t<
 51 |         !not_applicable<Detector, T const&, U const&>::value,
 52 |         bool
 53 |     >;
 54 | ///////////////////// std::enable_if_t like functions that enable only if types do not support operation
 55 | 
 56 |     template <class T, class U> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T, U>;
 57 |     template <class T, class U> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T, U>;
 58 |     template <class T, class U> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T, U>;
 59 |     template <class T, class U> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T, U>;
 60 |     template <class T, class U> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T, U>;
 61 |     template <class T, class U> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T, U>;
 62 | 
 63 |     template <class T> using enable_not_hashable_t = std::enable_if_t<
 64 |         not_applicable<hash_detector, const T&, const T&>::value,
 65 |         std::size_t
 66 |     >;
 67 | ///////////////////// std::enable_if_t like functions that enable only if types do support operation
 68 | 
 69 |     template <class T, class U> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T, U>;
 70 |     template <class T, class U> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T, U>;
 71 |     template <class T, class U> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T, U>;
 72 |     template <class T, class U> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T, U>;
 73 |     template <class T, class U> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T, U>;
 74 |     template <class T, class U> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T, U>;
 75 | 
 76 |     template <class T> using enable_hashable_t = std::enable_if_t<
 77 |         !not_applicable<hash_detector, const T&, const T&>::value,
 78 |         std::size_t
 79 |     >;
 80 | } // namespace detail
 81 | 
 82 | PFR_BEGIN_MODULE_EXPORT
 83 | 
 84 | /// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators available returns \forcedlink{eq_fields}(lhs, rhs).
 85 | ///
 86 | /// \returns true if lhs is equal to rhs; false otherwise
 87 | template <class T, class U>
 88 | constexpr detail::enable_not_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) noexcept {
 89 |     return pfr::eq_fields(lhs, rhs);
 90 | }
 91 | 
 92 | /// \overload eq
 93 | template <class T, class U>
 94 | constexpr detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
 95 |     return lhs == rhs;
 96 | }
 97 | 
 98 | 
 99 | /// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators available returns \forcedlink{ne_fields}(lhs, rhs).
100 | ///
101 | /// \returns true if lhs is not equal to rhs; false otherwise
102 | template <class T, class U>
103 | constexpr detail::enable_not_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) noexcept {
104 |     return pfr::ne_fields(lhs, rhs);
105 | }
106 | 
107 | /// \overload ne
108 | template <class T, class U>
109 | constexpr detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
110 |     return lhs != rhs;
111 | }
112 | 
113 | 
114 | /// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
115 | ///
116 | /// \returns true if lhs is less than rhs; false otherwise
117 | template <class T, class U>
118 | constexpr detail::enable_not_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) noexcept {
119 |     return pfr::lt_fields(lhs, rhs);
120 | }
121 | 
122 | /// \overload lt
123 | template <class T, class U>
124 | constexpr detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
125 |     return lhs < rhs;
126 | }
127 | 
128 | 
129 | /// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
130 | ///
131 | /// \returns true if lhs is greater than rhs; false otherwise
132 | template <class T, class U>
133 | constexpr detail::enable_not_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) noexcept {
134 |     return pfr::gt_fields(lhs, rhs);
135 | }
136 | 
137 | /// \overload gt
138 | template <class T, class U>
139 | constexpr detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
140 |     return lhs > rhs;
141 | }
142 | 
143 | 
144 | /// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{le_fields}(lhs, rhs).
145 | ///
146 | /// \returns true if lhs is less or equal to rhs; false otherwise
147 | template <class T, class U>
148 | constexpr detail::enable_not_le_comp_t<T, U> le(const T& lhs, const U& rhs) noexcept {
149 |     return pfr::le_fields(lhs, rhs);
150 | }
151 | 
152 | /// \overload le
153 | template <class T, class U>
154 | constexpr detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
155 |     return lhs <= rhs;
156 | }
157 | 
158 | 
159 | /// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{ge_fields}(lhs, rhs).
160 | ///
161 | /// \returns true if lhs is greater or equal to rhs; false otherwise
162 | template <class T, class U>
163 | constexpr detail::enable_not_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) noexcept {
164 |     return pfr::ge_fields(lhs, rhs);
165 | }
166 | 
167 | /// \overload ge
168 | template <class T, class U>
169 | constexpr detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
170 |     return lhs >= rhs;
171 | }
172 | 
173 | 
174 | /// \brief Hashes value using its own std::hash specialization; if no std::hash specialization available returns \forcedlink{hash_fields}(value).
175 | ///
176 | /// \returns std::size_t with hash of the value
177 | template <class T>
178 | constexpr detail::enable_not_hashable_t<T> hash_value(const T& value) noexcept {
179 |     return pfr::hash_fields(value);
180 | }
181 | 
182 | /// \overload hash_value
183 | template <class T>
184 | constexpr detail::enable_hashable_t<T> hash_value(const T& value) {
185 |     return std::hash<T>{}(value);
186 | }
187 | 
188 | PFR_END_MODULE_EXPORT
189 | 
190 | } // namespace pfr
191 | 
192 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
193 | 
194 | #endif // PFR_OPS_HPP
195 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core14_loophole.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin.
  2 | // Copyright (c) 2019-2025 Antony Polukhin.
  3 | //
  4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | 
  7 | 
  8 | // The Great Type Loophole (C++14)
  9 | // Initial implementation by Alexandr Poltavsky, http://alexpolt.github.io
 10 | //
 11 | // Description:
 12 | //  The Great Type Loophole is a technique that allows to exchange type information with template
 13 | //  instantiations. Basically you can assign and read type information during compile time.
 14 | //  Here it is used to detect data members of a data type. I described it for the first time in
 15 | //  this blog post http://alexpolt.github.io/type-loophole.html .
 16 | //
 17 | // This technique exploits the http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118
 18 | // CWG 2118. Stateful metaprogramming via friend injection
 19 | // Note: CWG agreed that such techniques should be ill-formed, although the mechanism for prohibiting them is as yet undetermined.
 20 | 
 21 | #ifndef PFR_DETAIL_CORE14_LOOPHOLE_HPP
 22 | #define PFR_DETAIL_CORE14_LOOPHOLE_HPP
 23 | #pragma once
 24 | 
 25 | #include <pfr/detail/config.hpp>
 26 | 
 27 | #include <pfr/detail/offset_based_getter.hpp>
 28 | #include <pfr/detail/fields_count.hpp>
 29 | #include <pfr/detail/make_flat_tuple_of_references.hpp>
 30 | #include <pfr/detail/make_integer_sequence.hpp>
 31 | #include <pfr/detail/sequence_tuple.hpp>
 32 | #include <pfr/detail/rvalue_t.hpp>
 33 | #include <pfr/detail/unsafe_declval.hpp>
 34 | 
 35 | #if !defined(PFR_INTERFACE_UNIT)
 36 | #include <utility>
 37 | #endif
 38 | 
 39 | #ifdef __clang__
 40 | #   pragma clang diagnostic push
 41 | #   pragma clang diagnostic ignored "-Wmissing-braces"
 42 | #   pragma clang diagnostic ignored "-Wundefined-inline"
 43 | #   pragma clang diagnostic ignored "-Wundefined-internal"
 44 | #   pragma clang diagnostic ignored "-Wmissing-field-initializers"
 45 | #elif defined(__GNUC__)
 46 | #   pragma GCC diagnostic push
 47 | #   pragma GCC diagnostic ignored "-Wnon-template-friend"
 48 | #endif
 49 | 
 50 | 
 51 | namespace pfr { namespace detail {
 52 | 
 53 | // tag<T,N> generates friend declarations and helps with overload resolution.
 54 | // There are two types: one with the auto return type, which is the way we read types later.
 55 | // The second one is used in the detection of instantiations without which we'd get multiple
 56 | // definitions.
 57 | 
 58 | template <class T, std::size_t N>
 59 | struct tag {
 60 |     friend auto loophole(tag<T,N>);
 61 | };
 62 | 
 63 | // The definitions of friend functions.
 64 | template <class T, class U, std::size_t N, bool B>
 65 | struct fn_def_lref {
 66 |     friend auto loophole(tag<T,N>) {
 67 |         // Standard Library containers do not SFINAE on invalid copy constructor. Because of that std::vector<std::unique_ptr<int>> reports that it is copyable,
 68 |         // which leads to an instantiation error at this place.
 69 |         //
 70 |         // To workaround the issue, we check that the type U is movable, and move it in that case.
 71 |         using no_extents_t = std::remove_all_extents_t<U>;
 72 |         return static_cast< std::conditional_t<std::is_move_constructible<no_extents_t>::value, no_extents_t&&, no_extents_t&> >(
 73 |             pfr::detail::unsafe_declval<no_extents_t&>()
 74 |         );
 75 |     }
 76 | };
 77 | template <class T, class U, std::size_t N, bool B>
 78 | struct fn_def_rref {
 79 |     friend auto loophole(tag<T,N>) { return std::move(pfr::detail::unsafe_declval< std::remove_all_extents_t<U>& >()); }
 80 | };
 81 | 
 82 | 
 83 | // Those specializations are to avoid multiple definition errors.
 84 | template <class T, class U, std::size_t N>
 85 | struct fn_def_lref<T, U, N, true> {};
 86 | 
 87 | template <class T, class U, std::size_t N>
 88 | struct fn_def_rref<T, U, N, true> {};
 89 | 
 90 | 
 91 | // This has a templated conversion operator which in turn triggers instantiations.
 92 | // Important point, using sizeof seems to be more reliable. Also default template
 93 | // arguments are "cached" (I think). To fix that I provide a U template parameter to
 94 | // the ins functions which do the detection using constexpr friend functions and SFINAE.
 95 | template <class T, std::size_t N>
 96 | struct loophole_ubiq_lref {
 97 |     template<class U, std::size_t M> static std::size_t ins(...);
 98 |     template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
 99 | 
100 |     template<class U, std::size_t = sizeof(fn_def_lref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
101 |     constexpr operator U&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
102 | };
103 | 
104 | template <class T, std::size_t N>
105 | struct loophole_ubiq_rref {
106 |     template<class U, std::size_t M> static std::size_t ins(...);
107 |     template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
108 | 
109 |     template<class U, std::size_t = sizeof(fn_def_rref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
110 |     constexpr operator U&&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
111 | };
112 | 
113 | 
114 | // This is a helper to turn a data structure into a tuple.
115 | template <class T, class U>
116 | struct loophole_type_list_lref;
117 | 
118 | template <typename T, std::size_t... I>
119 | struct loophole_type_list_lref< T, std::index_sequence<I...> >
120 |      // Instantiating loopholes:
121 |     : sequence_tuple::tuple< decltype(T{ loophole_ubiq_lref<T, I>{}... }, 0) >
122 | {
123 |     using type = sequence_tuple::tuple< decltype(loophole(tag<T, I>{}))... >;
124 | };
125 | 
126 | 
127 | template <class T, class U>
128 | struct loophole_type_list_rref;
129 | 
130 | template <typename T, std::size_t... I>
131 | struct loophole_type_list_rref< T, std::index_sequence<I...> >
132 |      // Instantiating loopholes:
133 |     : sequence_tuple::tuple< decltype(T{ loophole_ubiq_rref<T, I>{}... }, 0) >
134 | {
135 |     using type = sequence_tuple::tuple< decltype(loophole(tag<T, I>{}))... >;
136 | };
137 | 
138 | 
139 | // Lazily returns loophole_type_list_{lr}ref.
140 | template <bool IsCopyConstructible /*= true*/, class T, class U>
141 | struct loophole_type_list_selector {
142 |     using type = loophole_type_list_lref<T, U>;
143 | };
144 | 
145 | template <class T, class U>
146 | struct loophole_type_list_selector<false /*IsCopyConstructible*/, T, U> {
147 |     using type = loophole_type_list_rref<T, U>;
148 | };
149 | 
150 | template <class T>
151 | auto tie_as_tuple_loophole_impl(T& lvalue) noexcept {
152 |     using type = std::remove_cv_t<std::remove_reference_t<T>>;
153 |     using indexes = detail::make_index_sequence<fields_count<type>()>;
154 |     using loophole_type_list = typename detail::loophole_type_list_selector<
155 |         std::is_copy_constructible<std::remove_all_extents_t<type>>::value, type, indexes
156 |     >::type;
157 |     using tuple_type = typename loophole_type_list::type;
158 | 
159 |     return pfr::detail::make_flat_tuple_of_references(
160 |         lvalue,
161 |         offset_based_getter<type, tuple_type>{},
162 |         size_t_<0>{},
163 |         size_t_<tuple_type::size_v>{}
164 |     );
165 | }
166 | 
167 | template <class T>
168 | auto tie_as_tuple(T& val) noexcept {
169 |     static_assert(
170 |         !std::is_union<T>::value,
171 |         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
172 |     );
173 |     return pfr::detail::tie_as_tuple_loophole_impl(
174 |         val
175 |     );
176 | }
177 | 
178 | template <class T, class F, std::size_t... I>
179 | void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
180 |     static_assert(
181 |         !std::is_union<T>::value,
182 |         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
183 |     );
184 |     std::forward<F>(f)(
185 |         pfr::detail::tie_as_tuple_loophole_impl(t)
186 |     );
187 | }
188 | 
189 | }} // namespace pfr::detail
190 | 
191 | 
192 | #ifdef __clang__
193 | #   pragma clang diagnostic pop
194 | #elif defined(__GNUC__)
195 | #   pragma GCC diagnostic pop
196 | #endif
197 | 
198 | 
199 | #endif // PFR_DETAIL_CORE14_LOOPHOLE_HPP
200 | 
201 | 


--------------------------------------------------------------------------------
/misc/generate_fields_names_big.cpp.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
  2 | #
  3 | # Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | 
  7 | # Initial implementation by Bela Schaum, https://github.com/schaumb
  8 | # The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
  9 | #
 10 | 
 11 | ############################################################################################################################
 12 | 
 13 | import sys
 14 | import string
 15 | import random
 16 | 
 17 | # a bigger value might lead to compiler out of heap space error on MSVC
 18 | STRUCT_COUNT = 50
 19 | MAX_FIELD_COUNT = 50
 20 | 
 21 | MAIN_TEMPLATE = """// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov, Antony Polukhin.
 22 | //
 23 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
 24 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 25 | 
 26 | // Generated by misc/generate_fields_names_big.cpp.py
 27 | 
 28 | #include <pfr/core_name.hpp>
 29 | #include <type_traits>
 30 | 
 31 | #include <boost/core/lightweight_test.hpp>
 32 | 
 33 | namespace testing {
 34 | 
 35 | template <class... Types>
 36 | auto make_stdarray(const Types&... t) {
 37 |     return std::array<std::common_type_t<Types...>, sizeof...(Types)>{t...};
 38 | }
 39 | 
 40 | %STRUCTS_LIST%
 41 | 
 42 | %TEST_GET_NAME_DEFINITIONS_LIST%
 43 | 
 44 | %TEST_GET_NAMES_AS_ARRAY_DEFINITIONS_LIST%
 45 | 
 46 | 
 47 | } // namespace testing
 48 | 
 49 | int main() {
 50 |     %TEST_GET_NAME_CALLS_LIST%
 51 |     %TEST_GET_NAMES_AS_ARRAY_CALLS_LIST%
 52 | 
 53 |     return boost::report_errors();
 54 | }
 55 | """
 56 | 
 57 | STRUCT_TEMPLATE = """struct Aggregate%STRUCT_ID% {
 58 |     %FIELD_DEFINITIONS_LIST%
 59 | };
 60 | """
 61 | 
 62 | STRUCT_FIELD_DEFINITION_TEMPLATE = """int %FIELD_NAME%;
 63 | """
 64 | 
 65 | TEST_GET_NAME_TEMPLATE = """void test_get_name_%TEST_ID%() {
 66 |     %CHECKERS_LIST%
 67 | }
 68 | """
 69 | 
 70 | TEST_GET_NAME_CHECKER_TEMPLATE = """BOOST_TEST_EQ( ((pfr::get_name<%FIELD_ID%, Aggregate%STRUCT_ID%>())), "%FIELD_NAME%");
 71 | """
 72 | 
 73 | TEST_GET_NAMES_AS_ARRAY_TEMPLATE = """void test_names_as_array_%TEST_ID%() {
 74 |     const auto expected = make_stdarray(
 75 |         %FIELD_NAMES_LIST%
 76 |     );
 77 |     const auto value = pfr::names_as_array<Aggregate%STRUCT_ID%>();
 78 |     BOOST_TEST_EQ(expected.size(), value.size());
 79 |     for (std::size_t i=0;i<expected.size();++i) {
 80 |         BOOST_TEST_EQ(value[i], expected[i]);
 81 |     }
 82 | }
 83 | """
 84 | 
 85 | FIELD_NAME_TEMPLATE = """std::string_view{"%FIELD_NAME%"}
 86 | """
 87 | 
 88 | TEST_GET_NAME_CALL_TEMPLATE = """testing::test_get_name_%TEST_ID%();
 89 | """
 90 | 
 91 | TEST_GET_NAMES_AS_ARRAY_CALL_TEMPLATE = """testing::test_names_as_array_%TEST_ID%();
 92 | """
 93 | 
 94 | ############################################################################################################################
 95 | 
 96 | field_names = {
 97 |     "alignas": True,
 98 |     "alignof": True,
 99 |     "and": True,
100 |     "and_eq": True,
101 |     "asm": True,
102 |     "atomic_cancel": True,
103 |     "atomic_commit": True,
104 |     "atomic_noexcept": True,
105 |     "auto": True,
106 |     "bitand": True,
107 |     "bitor": True,
108 |     "bool": True,
109 |     "break": True,
110 |     "case": True,
111 |     "catch": True,
112 |     "char": True,
113 |     "char8_t": True,
114 |     "char16_t": True,
115 |     "char32_t": True,
116 |     "class": True,
117 |     "compl": True,
118 |     "concept": True,
119 |     "const": True,
120 |     "consteval": True,
121 |     "constexpr": True,
122 |     "constinit": True,
123 |     "const_cast": True,
124 |     "continue": True,
125 |     "co_await": True,
126 |     "co_return": True,
127 |     "co_yield": True,
128 |     "decltype": True,
129 |     "default": True,
130 |     "delete": True,
131 |     "do": True,
132 |     "double": True,
133 |     "dynamic_cast": True,
134 |     "else": True,
135 |     "enum": True,
136 |     "explicit": True,
137 |     "export": True,
138 |     "extern": True,
139 |     "false": True,
140 |     "float": True,
141 |     "for": True,
142 |     "friend": True,
143 |     "goto": True,
144 |     "if": True,
145 |     "inline": True,
146 |     "int": True,
147 |     "long": True,
148 |     "mutable": True,
149 |     "namespace": True,
150 |     "new": True,
151 |     "noexcept": True,
152 |     "not": True,
153 |     "not_eq": True,
154 |     "nullptr": True,
155 |     "operator": True,
156 |     "or": True,
157 |     "or_eq": True,
158 |     "private": True,
159 |     "protected": True,
160 |     "public": True,
161 |     "reflexpr": True,
162 |     "register": True,
163 |     "reinterpret_cast": True,
164 |     "requires": True,
165 |     "return": True,
166 |     "short": True,
167 |     "signed": True,
168 |     "sizeof": True,
169 |     "static": True,
170 |     "static_assert": True,
171 |     "static_cast": True,
172 |     "struct": True,
173 |     "switch": True,
174 |     "synchronized": True,
175 |     "template": True,
176 |     "this": True,
177 |     "thread_local": True,
178 |     "throw": True,
179 |     "true": True,
180 |     "try": True,
181 |     "typedef": True,
182 |     "typeid": True,
183 |     "typename": True,
184 |     "union": True,
185 |     "unsigned": True,
186 |     "using": True,
187 |     "virtual": True,
188 |     "void": True,
189 |     "volatile": True,
190 |     "wchar_t": True,
191 |     "while": True,
192 |     "xor": True,
193 |     "xor_eq": True
194 | }
195 | field_names_by_id = {}
196 | 
197 | def generate_new_field_name():
198 |     result = ''
199 |     name_len = random.randint(1,100)
200 |     result += random.choice("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_")
201 |     for i in range(name_len-1):
202 |         result += random.choice("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789")
203 |     return result
204 | 
205 | def generate_field_name(struct_id, field_id):
206 |     key = (struct_id, field_id)
207 |     if not key in field_names_by_id:
208 |         new_name = generate_new_field_name()
209 |         while new_name in field_names:
210 |             new_name = generate_new_field_name()
211 |         field_names[new_name] = True
212 |         field_names_by_id[key] = new_name
213 |     return field_names_by_id[key]
214 | 
215 | def generate_struct(struct_id):
216 |     field_definitions = ''
217 |     fields_count = struct_id
218 |     for i in range(fields_count):
219 |         field_definitions += STRUCT_FIELD_DEFINITION_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, i))
220 |     return STRUCT_TEMPLATE.replace('%FIELD_DEFINITIONS_LIST%', field_definitions).replace('%STRUCT_ID%', str(struct_id))
221 | 
222 | def generate_structs_list():
223 |     result = ''
224 |     for i in range(STRUCT_COUNT):
225 |         result += generate_struct(i+1)
226 |     return result
227 | 
228 | def generate_test_get_name_definition(struct_id):
229 |     checkers_list = ''
230 |     fields_count = struct_id
231 |     for i in range(fields_count):
232 |         checkers_list += TEST_GET_NAME_CHECKER_TEMPLATE.replace('%FIELD_ID%', str(i)).replace('%STRUCT_ID%', str(struct_id)).replace('%FIELD_NAME%', generate_field_name(struct_id, i))
233 |     return TEST_GET_NAME_TEMPLATE.replace('%TEST_ID%', str(struct_id)).replace('%CHECKERS_LIST%', checkers_list)
234 | 
235 | def generate_test_get_name_definitions_list():
236 |     result = ''
237 |     for i in range(STRUCT_COUNT):
238 |         result += generate_test_get_name_definition(i+1)
239 |     return result
240 | 
241 | def generate_test_names_as_array_definition(struct_id):
242 |     field_names_list = FIELD_NAME_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, 0))
243 |     fields_count = struct_id
244 |     for i in range(1, fields_count):
245 |         field_names_list += ', ' + FIELD_NAME_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, i))
246 |     return TEST_GET_NAMES_AS_ARRAY_TEMPLATE.replace('%TEST_ID%', str(struct_id)).replace('%FIELD_NAMES_LIST%', field_names_list).replace('%STRUCT_ID%', str(struct_id))
247 | 
248 | def generate_test_names_as_array_definitions_list():
249 |     result = ''
250 |     for i in range(STRUCT_COUNT):
251 |         result += generate_test_names_as_array_definition(i+1)
252 |     return result
253 | 
254 | def generate_test_get_name_calls_list():
255 |     result = ''
256 |     for i in range(STRUCT_COUNT):
257 |         result += TEST_GET_NAME_CALL_TEMPLATE.replace('%TEST_ID%', str(i+1))
258 |     return result
259 | 
260 | def generate_test_names_as_array_calls_list():
261 |     result = ''
262 |     for i in range(STRUCT_COUNT):
263 |         result += TEST_GET_NAMES_AS_ARRAY_CALL_TEMPLATE.replace('%TEST_ID%', str(i+1))
264 |     return result
265 | 
266 | print(MAIN_TEMPLATE.replace('%STRUCTS_LIST%', generate_structs_list()).replace('%TEST_GET_NAME_DEFINITIONS_LIST%', generate_test_get_name_definitions_list()).replace('%TEST_GET_NAMES_AS_ARRAY_DEFINITIONS_LIST%', generate_test_names_as_array_definitions_list()).replace('%TEST_GET_NAME_CALLS_LIST%', generate_test_get_name_calls_list()).replace('%TEST_GET_NAMES_AS_ARRAY_CALLS_LIST%', generate_test_names_as_array_calls_list()))
267 | 
268 | 


--------------------------------------------------------------------------------
/include/pfr/detail/functional.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_DETAIL_FUNCTIONAL_HPP
  7 | #define PFR_DETAIL_FUNCTIONAL_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #include <pfr/detail/sequence_tuple.hpp>
 13 | 
 14 | #if !defined(PFR_INTERFACE_UNIT)
 15 | #include <cstdint>
 16 | #include <functional>
 17 | #endif
 18 | 
 19 | namespace pfr { namespace detail {
 20 |     template <std::size_t I, std::size_t N>
 21 |     struct equal_impl {
 22 |         template <class T, class U>
 23 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
 24 |             return ::pfr::detail::sequence_tuple::get<I>(v1) == ::pfr::detail::sequence_tuple::get<I>(v2)
 25 |                 && equal_impl<I + 1, N>::cmp(v1, v2);
 26 |         }
 27 |     };
 28 | 
 29 |     template <std::size_t N>
 30 |     struct equal_impl<N, N> {
 31 |         template <class T, class U>
 32 |         constexpr static bool cmp(const T&, const U&) noexcept {
 33 |             return T::size_v == U::size_v;
 34 |         }
 35 |     };
 36 | 
 37 |     template <std::size_t I, std::size_t N>
 38 |     struct not_equal_impl {
 39 |         template <class T, class U>
 40 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
 41 |             return ::pfr::detail::sequence_tuple::get<I>(v1) != ::pfr::detail::sequence_tuple::get<I>(v2)
 42 |                 || not_equal_impl<I + 1, N>::cmp(v1, v2);
 43 |         }
 44 |     };
 45 | 
 46 |     template <std::size_t N>
 47 |     struct not_equal_impl<N, N> {
 48 |         template <class T, class U>
 49 |         constexpr static bool cmp(const T&, const U&) noexcept {
 50 |             return T::size_v != U::size_v;
 51 |         }
 52 |     };
 53 | 
 54 |     template <std::size_t I, std::size_t N>
 55 |     struct less_impl {
 56 |         template <class T, class U>
 57 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
 58 |             return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
 59 |                 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_impl<I + 1, N>::cmp(v1, v2));
 60 |         }
 61 |     };
 62 | 
 63 |     template <std::size_t N>
 64 |     struct less_impl<N, N> {
 65 |         template <class T, class U>
 66 |         constexpr static bool cmp(const T&, const U&) noexcept {
 67 |             return T::size_v < U::size_v;
 68 |         }
 69 |     };
 70 | 
 71 |     template <std::size_t I, std::size_t N>
 72 |     struct less_equal_impl {
 73 |         template <class T, class U>
 74 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
 75 |             return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
 76 |                 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_equal_impl<I + 1, N>::cmp(v1, v2));
 77 |         }
 78 |     };
 79 | 
 80 |     template <std::size_t N>
 81 |     struct less_equal_impl<N, N> {
 82 |         template <class T, class U>
 83 |         constexpr static bool cmp(const T&, const U&) noexcept {
 84 |             return T::size_v <= U::size_v;
 85 |         }
 86 |     };
 87 | 
 88 |     template <std::size_t I, std::size_t N>
 89 |     struct greater_impl {
 90 |         template <class T, class U>
 91 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
 92 |             return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
 93 |                 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_impl<I + 1, N>::cmp(v1, v2));
 94 |         }
 95 |     };
 96 | 
 97 |     template <std::size_t N>
 98 |     struct greater_impl<N, N> {
 99 |         template <class T, class U>
100 |         constexpr static bool cmp(const T&, const U&) noexcept {
101 |             return T::size_v > U::size_v;
102 |         }
103 |     };
104 | 
105 |     template <std::size_t I, std::size_t N>
106 |     struct greater_equal_impl {
107 |         template <class T, class U>
108 |         constexpr static bool cmp(const T& v1, const U& v2) noexcept {
109 |             return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
110 |                 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_equal_impl<I + 1, N>::cmp(v1, v2));
111 |         }
112 |     };
113 | 
114 |     template <std::size_t N>
115 |     struct greater_equal_impl<N, N> {
116 |         template <class T, class U>
117 |         constexpr static bool cmp(const T&, const U&) noexcept {
118 |             return T::size_v >= U::size_v;
119 |         }
120 |     };
121 | 
122 |     // Hash combine functions copied from Boost.ContainerHash
123 |     // https://github.com/boostorg/container_hash/blob/171c012d4723c5e93cc7cffe42919afdf8b27dfa/include/boost/container_hash/hash.hpp#L311
124 |     // that is based on Peter Dimov's proposal
125 |     // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
126 |     // issue 6.18.
127 |     //
128 |     // This also contains public domain code from MurmurHash. From the
129 |     // MurmurHash header:
130 |     //
131 |     // MurmurHash3 was written by Austin Appleby, and is placed in the public
132 |     // domain. The author hereby disclaims copyright to this source code.
133 |     template <typename SizeT>
134 |     constexpr void hash_combine(SizeT& seed, SizeT value) noexcept {
135 |         seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
136 |     }
137 | 
138 |     constexpr auto rotl(std::uint32_t x, std::uint32_t r) noexcept {
139 |         return (x << r) | (x >> (32 - r));
140 |     }
141 | 
142 |     constexpr void hash_combine(std::uint32_t& h1, std::uint32_t k1) noexcept {
143 |           const std::uint32_t c1 = 0xcc9e2d51;
144 |           const std::uint32_t c2 = 0x1b873593;
145 | 
146 |           k1 *= c1;
147 |           k1 = detail::rotl(k1,15);
148 |           k1 *= c2;
149 | 
150 |           h1 ^= k1;
151 |           h1 = detail::rotl(h1,13);
152 |           h1 = h1*5+0xe6546b64;
153 |     }
154 | 
155 | #if defined(INT64_MIN) && defined(UINT64_MAX)
156 |     constexpr void hash_combine(std::uint64_t& h, std::uint64_t k) noexcept {
157 |         const std::uint64_t m = 0xc6a4a7935bd1e995ULL;
158 |         const int r = 47;
159 | 
160 |         k *= m;
161 |         k ^= k >> r;
162 |         k *= m;
163 | 
164 |         h ^= k;
165 |         h *= m;
166 | 
167 |         // Completely arbitrary number, to prevent 0's
168 |         // from hashing to 0.
169 |         h += 0xe6546b64;
170 |     }
171 | #endif
172 | 
173 |     template <typename T>
174 |     auto compute_hash(const T& value, long /*priority*/)
175 |         -> decltype(std::hash<T>()(value))
176 |     {
177 |         return std::hash<T>()(value);
178 |     }
179 | 
180 |     template <typename T>
181 |     std::size_t compute_hash(const T& /*value*/, int /*priority*/) {
182 |         static_assert(sizeof(T) && false, "====================> Boost.PFR: std::hash not specialized for type T");
183 |         return 0;
184 |     }
185 | 
186 |     template <std::size_t I, std::size_t N>
187 |     struct hash_impl {
188 |         template <class T>
189 |         constexpr static std::size_t compute(const T& val) noexcept {
190 |             std::size_t h = detail::compute_hash( ::pfr::detail::sequence_tuple::get<I>(val), 1L );
191 |             detail::hash_combine(h, hash_impl<I + 1, N>::compute(val) );
192 |             return h;
193 |         }
194 |     };
195 | 
196 |     template <std::size_t N>
197 |     struct hash_impl<N, N> {
198 |         template <class T>
199 |         constexpr static std::size_t compute(const T&) noexcept {
200 |             return 0;
201 |         }
202 |     };
203 | 
204 | ///////////////////// Define min_element and to avoid inclusion of <algorithm>
205 |     constexpr std::size_t min_size(std::size_t x, std::size_t y) noexcept {
206 |         return x < y ? x : y;
207 |     }
208 | 
209 |     template <template <std::size_t, std::size_t> class Visitor, class T, class U>
210 |     constexpr bool binary_visit(const T& x, const U& y) {
211 |         constexpr std::size_t fields_count_lhs = detail::fields_count<std::remove_reference_t<T>>();
212 |         constexpr std::size_t fields_count_rhs = detail::fields_count<std::remove_reference_t<U>>();
213 |         constexpr std::size_t fields_count_min = detail::min_size(fields_count_lhs, fields_count_rhs);
214 |         typedef Visitor<0, fields_count_min> visitor_t;
215 | 
216 | #if PFR_USE_CPP17 || PFR_USE_LOOPHOLE
217 |         return visitor_t::cmp(detail::tie_as_tuple(x), detail::tie_as_tuple(y));
218 | #else
219 |         bool result = true;
220 |         ::pfr::detail::for_each_field_dispatcher(
221 |             x,
222 |             [&result, &y](const auto& lhs) {
223 |                 constexpr std::size_t fields_count_rhs_ = detail::fields_count<std::remove_reference_t<U>>();
224 |                 ::pfr::detail::for_each_field_dispatcher(
225 |                     y,
226 |                     [&result, &lhs](const auto& rhs) {
227 |                         result = visitor_t::cmp(lhs, rhs);
228 |                     },
229 |                     detail::make_index_sequence<fields_count_rhs_>{}
230 |                 );
231 |             },
232 |             detail::make_index_sequence<fields_count_lhs>{}
233 |         );
234 | 
235 |         return result;
236 | #endif
237 |     }
238 | 
239 | }} // namespace pfr::detail
240 | 
241 | #endif // PFR_DETAIL_FUNCTIONAL_HPP
242 | 


--------------------------------------------------------------------------------
/include/pfr/core.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_CORE_HPP
  7 | #define PFR_CORE_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | 
 12 | #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
 13 | 
 14 | #include <pfr/detail/core.hpp>
 15 | 
 16 | #include <pfr/detail/sequence_tuple.hpp>
 17 | #include <pfr/detail/stdtuple.hpp>
 18 | #include <pfr/detail/for_each_field.hpp>
 19 | #include <pfr/detail/make_integer_sequence.hpp>
 20 | #include <pfr/detail/tie_from_structure_tuple.hpp>
 21 | 
 22 | #include <pfr/tuple_size.hpp>
 23 | 
 24 | #if !defined(PFR_INTERFACE_UNIT)
 25 | #include <type_traits>
 26 | #include <utility>      // metaprogramming stuff
 27 | #endif
 28 | 
 29 | /// \file pfr/core.hpp
 30 | /// Contains all the basic tuple-like interfaces \forcedlink{get}, \forcedlink{tuple_size}, \forcedlink{tuple_element_t}, and others.
 31 | ///
 32 | /// \b Synopsis:
 33 | 
 34 | namespace pfr {
 35 | 
 36 | PFR_BEGIN_MODULE_EXPORT
 37 | 
 38 | /// \brief Returns reference or const reference to a field with index `I` in \aggregate `val`.
 39 | /// Overload taking the type `U` returns reference or const reference to a field
 40 | /// with provided type `U` in \aggregate `val` if there's only one field of such type in `val`.
 41 | ///
 42 | /// \b Example:
 43 | /// \code
 44 | ///     struct my_struct { int i, short s; };
 45 | ///     my_struct s {10, 11};
 46 | ///
 47 | ///     assert(pfr::get<0>(s) == 10);
 48 | ///     pfr::get<1>(s) = 0;
 49 | ///
 50 | ///     assert(pfr::get<int>(s) == 10);
 51 | ///     pfr::get<short>(s) = 11;
 52 | /// \endcode
 53 | template <std::size_t I, class T>
 54 | constexpr decltype(auto) get(const T& val) noexcept {
 55 |     return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
 56 | }
 57 | 
 58 | /// \overload get
 59 | template <std::size_t I, class T>
 60 | constexpr decltype(auto) get(T& val
 61 | #if !PFR_USE_CPP17
 62 |     , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
 63 | #endif
 64 | ) noexcept {
 65 |     return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
 66 | }
 67 | 
 68 | #if !PFR_USE_CPP17
 69 | /// \overload get
 70 | template <std::size_t I, class T>
 71 | constexpr auto get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
 72 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling pfr::get on non const non assignable type is allowed only in C++17");
 73 |     return 0;
 74 | }
 75 | #endif
 76 | 
 77 | 
 78 | /// \overload get
 79 | template <std::size_t I, class T>
 80 | constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
 81 |     return std::move(detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) ));
 82 | }
 83 | 
 84 | 
 85 | /// \overload get
 86 | template <class U, class T>
 87 | constexpr const U& get(const T& val) noexcept {
 88 |     return detail::sequence_tuple::get_by_type_impl<const U&>( detail::tie_as_tuple(val) );
 89 | }
 90 | 
 91 | 
 92 | /// \overload get
 93 | template <class U, class T>
 94 | constexpr U& get(T& val
 95 | #if !PFR_USE_CPP17
 96 |     , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
 97 | #endif
 98 | ) noexcept {
 99 |     return detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) );
100 | }
101 | 
102 | #if !PFR_USE_CPP17
103 | /// \overload get
104 | template <class U, class T>
105 | constexpr U& get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
106 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling pfr::get on non const non assignable type is allowed only in C++17");
107 |     return 0;
108 | }
109 | #endif
110 | 
111 | 
112 | /// \overload get
113 | template <class U, class T>
114 | constexpr U&& get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
115 |     return std::move(detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) ));
116 | }
117 | 
118 | 
119 | /// \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T.
120 | ///
121 | /// \b Example:
122 | /// \code
123 | ///     std::vector< pfr::tuple_element<0, my_structure>::type > v;
124 | /// \endcode
125 | template <std::size_t I, class T>
126 | using tuple_element = detail::sequence_tuple::tuple_element<I, decltype( ::pfr::detail::tie_as_tuple(std::declval<T&>()) ) >;
127 | 
128 | 
129 | /// \brief Type of a field with index `I` in \aggregate `T`.
130 | ///
131 | /// \b Example:
132 | /// \code
133 | ///     std::vector< pfr::tuple_element_t<0, my_structure> > v;
134 | /// \endcode
135 | template <std::size_t I, class T>
136 | using tuple_element_t = typename tuple_element<I, T>::type;
137 | 
138 | 
139 | /// \brief Creates a `std::tuple` from fields of an \aggregate `val`.
140 | ///
141 | /// \b Example:
142 | /// \code
143 | ///     struct my_struct { int i, short s; };
144 | ///     my_struct s {10, 11};
145 | ///     std::tuple<int, short> t = pfr::structure_to_tuple(s);
146 | ///     assert(get<0>(t) == 10);
147 | /// \endcode
148 | template <class T>
149 | constexpr auto structure_to_tuple(const T& val) {
150 |     return detail::make_stdtuple_from_tietuple(
151 |         detail::tie_as_tuple(val),
152 |         detail::make_index_sequence< tuple_size_v<T> >()
153 |     );
154 | }
155 | 
156 | 
157 | /// \brief std::tie` like function that ties fields of a structure.
158 | ///
159 | /// \returns a `std::tuple` with lvalue and const lvalue references to fields of an \aggregate `val`.
160 | ///
161 | /// \b Example:
162 | /// \code
163 | ///     void foo(const int&, const short&);
164 | ///     struct my_struct { int i, short s; };
165 | ///
166 | ///     const my_struct const_s{1, 2};
167 | ///     std::apply(foo, pfr::structure_tie(const_s));
168 | ///
169 | ///     my_struct s;
170 | ///     pfr::structure_tie(s) = std::tuple<int, short>{10, 11};
171 | ///     assert(s.s == 11);
172 | /// \endcode
173 | template <class T>
174 | constexpr auto structure_tie(const T& val) noexcept {
175 |     return detail::make_conststdtiedtuple_from_tietuple(
176 |         detail::tie_as_tuple(const_cast<T&>(val)),
177 |         detail::make_index_sequence< tuple_size_v<T> >()
178 |     );
179 | }
180 | 
181 | 
182 | /// \overload structure_tie
183 | template <class T>
184 | constexpr auto structure_tie(T& val
185 | #if !PFR_USE_CPP17
186 |     , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
187 | #endif
188 | ) noexcept {
189 |     return detail::make_stdtiedtuple_from_tietuple(
190 |         detail::tie_as_tuple(val),
191 |         detail::make_index_sequence< tuple_size_v<T> >()
192 |     );
193 | }
194 | 
195 | #if !PFR_USE_CPP17
196 | /// \overload structure_tie
197 | template <class T>
198 | constexpr auto structure_tie(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
199 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling pfr::structure_tie on non const non assignable type is allowed only in C++17");
200 |     return 0;
201 | }
202 | #endif
203 | 
204 | 
205 | /// \overload structure_tie
206 | template <class T>
207 | constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
208 |     static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling pfr::structure_tie on rvalue references is forbidden");
209 |     return 0;
210 | }
211 | 
212 | /// Calls `func` for each field of a `value`.
213 | ///
214 | /// \param func must have one of the following signatures:
215 | ///     * any_return_type func(U&& field)                // field of value is perfect forwarded to function
216 | ///     * any_return_type func(U&& field, std::size_t i)
217 | ///     * any_return_type func(U&& value, I i)           // Here I is an `std::integral_constant<size_t, field_index>`
218 | ///
219 | /// \param value To each field of this variable will be the `func` applied.
220 | ///
221 | /// \b Example:
222 | /// \code
223 | ///     struct my_struct { int i, short s; };
224 | ///     int sum = 0;
225 | ///     pfr::for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
226 | ///     assert(sum == 42);
227 | /// \endcode
228 | template <class T, class F>
229 | constexpr void for_each_field(T&& value, F&& func) {
230 |     return ::pfr::detail::for_each_field(std::forward<T>(value), std::forward<F>(func));
231 | }
232 | 
233 | /// \brief std::tie-like function that allows assigning to tied values from aggregates.
234 | ///
235 | /// \returns an object with lvalue references to `args...`; on assignment of an \aggregate value to that
236 | /// object each field of an aggregate is assigned to the corresponding `args...` reference.
237 | ///
238 | /// \b Example:
239 | /// \code
240 | ///     auto f() {
241 | ///       struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 };
242 | ///       return res;
243 | ///     }
244 | ///     auto [p, s] = f();
245 | ///     pfr::tie_from_structure(p, s) = f();
246 | /// \endcode
247 | template <typename... Elements>
248 | constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Elements&... args) noexcept {
249 |     return detail::tie_from_structure_tuple<Elements...>(args...);
250 | }
251 | 
252 | PFR_END_MODULE_EXPORT
253 | 
254 | } // namespace pfr
255 | 
256 | #endif  // #if !defined(PFR_USE_MODULES) || defined(PFR_INTERFACE_UNIT)
257 | 
258 | #endif // PFR_CORE_HPP
259 | 


--------------------------------------------------------------------------------
/include/pfr/detail/core_name20_static.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | 
  7 | // Initial implementation by Bela Schaum, https://github.com/schaumb
  8 | // The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
  9 | //
 10 | 
 11 | #ifndef PFR_DETAIL_CORE_NAME20_STATIC_HPP
 12 | #define PFR_DETAIL_CORE_NAME20_STATIC_HPP
 13 | #pragma once
 14 | 
 15 | #include <pfr/detail/config.hpp>
 16 | 
 17 | #include <pfr/detail/core.hpp>
 18 | #include <pfr/detail/fake_object.hpp>
 19 | #include <pfr/detail/fields_count.hpp>
 20 | #include <pfr/detail/for_each_field.hpp>
 21 | #include <pfr/detail/make_integer_sequence.hpp>
 22 | #include <pfr/detail/sequence_tuple.hpp>
 23 | #include <pfr/detail/stdarray.hpp>
 24 | 
 25 | #if !defined(PFR_INTERFACE_UNIT)
 26 | #include <type_traits>
 27 | #include <string_view>
 28 | #include <array>
 29 | #include <memory> // for std::addressof
 30 | #endif
 31 | 
 32 | namespace pfr { namespace detail {
 33 | 
 34 | struct core_name_skip {
 35 |     std::size_t size_at_begin;
 36 |     std::size_t size_at_end;
 37 |     bool is_backward;
 38 |     std::string_view until_runtime;
 39 | 
 40 |     consteval std::string_view apply(std::string_view sv) const noexcept {
 41 |         // We use std::min here to make the compiler diagnostic shorter and
 42 |         // cleaner in case of misconfigured PFR_CORE_NAME_PARSING
 43 |         sv.remove_prefix((std::min)(size_at_begin, sv.size()));
 44 |         sv.remove_suffix((std::min)(size_at_end, sv.size()));
 45 |         if (until_runtime.empty()) {
 46 |             return sv;
 47 |         }
 48 | 
 49 |         const auto found = is_backward ? sv.rfind(until_runtime)
 50 |                                        : sv.find(until_runtime);
 51 | 
 52 |         const auto cut_until = found + until_runtime.size();
 53 |         const auto safe_cut_until = (std::min)(cut_until, sv.size());
 54 |         return sv.substr(safe_cut_until);
 55 |     }
 56 | };
 57 | 
 58 | struct backward {
 59 |     explicit consteval backward(std::string_view value) noexcept
 60 |         : value(value)
 61 |     {}
 62 | 
 63 |     std::string_view value;
 64 | };
 65 | 
 66 | consteval core_name_skip make_core_name_skip(std::size_t size_at_begin,
 67 |                                              std::size_t size_at_end,
 68 |                                              std::string_view until_runtime) noexcept
 69 | {
 70 |     return core_name_skip{size_at_begin, size_at_end, false, until_runtime};
 71 | }
 72 | 
 73 | consteval core_name_skip make_core_name_skip(std::size_t size_at_begin,
 74 |                                              std::size_t size_at_end,
 75 |                                              backward until_runtime) noexcept
 76 | {
 77 |     return core_name_skip{size_at_begin, size_at_end, true, until_runtime.value};
 78 | }
 79 | 
 80 | // it might be compilation failed without this workaround sometimes
 81 | // See https://github.com/llvm/llvm-project/issues/41751 for details
 82 | template <class>
 83 | consteval std::string_view clang_workaround(std::string_view value) noexcept
 84 | {
 85 |     return value;
 86 | }
 87 | 
 88 | template <class MsvcWorkaround, auto ptr>
 89 | consteval auto name_of_field_impl() noexcept {
 90 |     // Some of the following compiler specific macro may be defined only
 91 |     // inside the function body:
 92 | 
 93 | #ifndef PFR_FUNCTION_SIGNATURE
 94 | #   if defined(__FUNCSIG__)
 95 | #       define PFR_FUNCTION_SIGNATURE __FUNCSIG__
 96 | #   elif defined(__PRETTY_FUNCTION__) || defined(__GNUC__) || defined(__clang__)
 97 | #       define PFR_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
 98 | #   else
 99 | #       define PFR_FUNCTION_SIGNATURE ""
100 | #   endif
101 | #endif
102 | 
103 |     constexpr std::string_view sv = detail::clang_workaround<MsvcWorkaround>(PFR_FUNCTION_SIGNATURE);
104 |     static_assert(!sv.empty(),
105 |         "====================> Boost.PFR: Field reflection parser configured in a wrong way. "
106 |         "Please define the PFR_FUNCTION_SIGNATURE to a compiler specific macro, "
107 |         "that outputs the whole function signature including non-type template parameters."
108 |     );
109 | 
110 |     constexpr auto skip = detail::make_core_name_skip PFR_CORE_NAME_PARSING;
111 |     static_assert(skip.size_at_begin + skip.size_at_end + skip.until_runtime.size() < sv.size(),
112 |         "====================> Boost.PFR: Field reflection parser configured in a wrong way. "
113 |         "It attempts to skip more chars than available. "
114 |         "Please define PFR_CORE_NAME_PARSING to correct values. See documentation section "
115 |         "'Limitations and Configuration' for more information."
116 |     );
117 |     constexpr auto fn = skip.apply(sv);
118 |     static_assert(
119 |         !fn.empty(),
120 |         "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. "
121 |         "It skipped all the input, leaving the field name empty. "
122 |         "Please define PFR_CORE_NAME_PARSING to correct values. See documentation section "
123 |         "'Limitations and Configuration' for more information."
124 |     );
125 |     auto res = std::array<char, fn.size()+1>{};
126 | 
127 |     auto* out = res.data();
128 |     for (auto x: fn) {
129 |         *out = x;
130 |         ++out;
131 |     }
132 | 
133 |     return res;
134 | }
135 | 
136 | #ifdef __clang__
137 | #pragma clang diagnostic push
138 | #pragma clang diagnostic ignored "-Wundefined-var-template"
139 | 
140 | // clang 16 and earlier don't support address of non-static member as template parameter
141 | // but fortunately it's possible to use C++20 non-type template parameters in another way
142 | // even in clang 16 and more older clangs
143 | // all we need is to wrap pointer into 'clang_wrapper_t' and then pass it into template
144 | template <class T>
145 | struct clang_wrapper_t {
146 |     T v;
147 | };
148 | template <class T>
149 | clang_wrapper_t(T) -> clang_wrapper_t<T>;
150 | 
151 | template <class T>
152 | constexpr auto make_clang_wrapper(const T& arg) noexcept {
153 |     return clang_wrapper_t{arg};
154 | }
155 | 
156 | #else
157 | 
158 | template <class T>
159 | constexpr const T& make_clang_wrapper(const T& arg) noexcept {
160 |     // It's everything OK with address of non-static member as template parameter support on this compiler
161 |     // so we don't need a wrapper here, just pass the pointer into template
162 |     return arg;
163 | }
164 | 
165 | #endif
166 | 
167 | template <class MsvcWorkaround, auto ptr>
168 | consteval auto name_of_field() noexcept {
169 |     // Sanity check: known field name must match the deduced one
170 |     static_assert(
171 |         sizeof(MsvcWorkaround)  // do not trigger if `name_of_field()` is not used
172 |         && std::string_view{
173 |             detail::name_of_field_impl<
174 |                 core_name_skip, detail::make_clang_wrapper(std::addressof(
175 |                     detail::fake_object<core_name_skip>().size_at_begin
176 |                 ))
177 |             >().data()
178 |         } == "size_at_begin",
179 |         "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. "
180 |         "It does not return the proper field name. "
181 |         "Please define PFR_CORE_NAME_PARSING to correct values. See documentation section "
182 |         "'Limitations and Configuration' for more information."
183 |     );
184 | 
185 |     return detail::name_of_field_impl<MsvcWorkaround, ptr>();
186 | }
187 | 
188 | // Storing part of a string literal into an array minimizes the binary size.
189 | //
190 | // Without passing 'T' into 'name_of_field' different fields from different structures might have the same name!
191 | // See https://developercommunity.visualstudio.com/t/__FUNCSIG__-outputs-wrong-value-with-C/10458554 for details
192 | template <class T, std::size_t I>
193 | inline constexpr auto stored_name_of_field = detail::name_of_field<T,
194 |     detail::make_clang_wrapper(std::addressof(detail::sequence_tuple::get<I>(
195 |         detail::tie_as_tuple(detail::fake_object<T>())
196 |     )))
197 | >();
198 | 
199 | #ifdef __clang__
200 | #pragma clang diagnostic pop
201 | #endif
202 | 
203 | template <class T, std::size_t... I>
204 | constexpr auto tie_as_names_tuple_impl(std::index_sequence<I...>) noexcept {
205 |     return detail::sequence_tuple::make_sequence_tuple(std::string_view{stored_name_of_field<T, I>.data()}...);
206 | }
207 | 
208 | template <class T, std::size_t I>
209 | constexpr std::string_view get_name() noexcept {
210 |     static_assert(
211 |         !std::is_union<T>::value,
212 |         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
213 |     );
214 |     static_assert(
215 |         !std::is_array<T>::value,
216 |         "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members"
217 |     );
218 |     static_assert(
219 |         sizeof(T) && PFR_USE_CPP17,
220 |         "====================> Boost.PFR: Extraction of field's names is allowed only when the PFR_USE_CPP17 macro enabled."
221 |    );
222 | 
223 |    return stored_name_of_field<T, I>.data();
224 | }
225 | 
226 | template <class T>
227 | constexpr auto tie_as_names_tuple() noexcept {
228 |     static_assert(
229 |         !std::is_union<T>::value,
230 |         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
231 |     );
232 |     static_assert(
233 |         !std::is_array<T>::value,
234 |         "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members"
235 |     );
236 |     static_assert(
237 |         sizeof(T) && PFR_USE_CPP17,
238 |         "====================> Boost.PFR: Extraction of field's names is allowed only when the PFR_USE_CPP17 macro enabled."
239 |     );
240 | 
241 |     return detail::tie_as_names_tuple_impl<T>(detail::make_index_sequence<detail::fields_count<T>()>{});
242 | }
243 | 
244 | template <class T, class F>
245 | constexpr void for_each_field_with_name(T&& value, F&& func) {
246 |     return pfr::detail::for_each_field(
247 |         std::forward<T>(value),
248 |         [f = std::forward<F>(func)](auto&& field, auto index) mutable {
249 |             using IndexType = decltype(index);
250 |             using FieldType = decltype(field);
251 |             constexpr auto name = pfr::detail::get_name<std::remove_reference_t<T>, IndexType::value>();
252 |             if constexpr (std::is_invocable_v<F, std::string_view, FieldType, IndexType>) {
253 |                 f(name, std::forward<FieldType>(field), index);
254 |             } else {
255 |                 f(name, std::forward<FieldType>(field));
256 |             }
257 |         });
258 | }
259 | 
260 | }} // namespace pfr::detail
261 | 
262 | #endif // PFR_DETAIL_CORE_NAME20_STATIC_HPP
263 | 
264 | 


--------------------------------------------------------------------------------
/include/pfr/detail/fields_count.hpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016-2025 Antony Polukhin
  2 | //
  3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying
  4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5 | 
  6 | #ifndef PFR_DETAIL_FIELDS_COUNT_HPP
  7 | #define PFR_DETAIL_FIELDS_COUNT_HPP
  8 | #pragma once
  9 | 
 10 | #include <pfr/detail/config.hpp>
 11 | #include <pfr/detail/make_integer_sequence.hpp>
 12 | #include <pfr/detail/size_t_.hpp>
 13 | #include <pfr/detail/unsafe_declval.hpp>
 14 | 
 15 | #if !defined(PFR_INTERFACE_UNIT)
 16 | #include <limits>
 17 | #include <type_traits>
 18 | #include <utility>      // metaprogramming stuff
 19 | #endif
 20 | 
 21 | #ifdef __clang__
 22 | #   pragma clang diagnostic push
 23 | #   pragma clang diagnostic ignored "-Wmissing-braces"
 24 | #   pragma clang diagnostic ignored "-Wundefined-inline"
 25 | #   pragma clang diagnostic ignored "-Wundefined-internal"
 26 | #   pragma clang diagnostic ignored "-Wmissing-field-initializers"
 27 | #endif
 28 | 
 29 | namespace pfr { namespace detail {
 30 | 
 31 | ///////////////////// min without including <algorithm>
 32 | constexpr std::size_t min_of_size_t(std::size_t a, std::size_t b) noexcept {
 33 |     return b < a ? b : a;
 34 | }
 35 | 
 36 | ///////////////////// Structure that can be converted to reference to anything
 37 | struct ubiq_lref_constructor {
 38 |     std::size_t ignore;
 39 |     template <class Type> constexpr operator Type&() const && noexcept {  // tweak for template_unconstrained.cpp like cases
 40 |         return detail::unsafe_declval<Type&>();
 41 |     }
 42 | 
 43 |     template <class Type> constexpr operator Type&() const & noexcept {  // tweak for optional_chrono.cpp like cases
 44 |         return detail::unsafe_declval<Type&>();
 45 |     }
 46 | };
 47 | 
 48 | ///////////////////// Structure that can be converted to rvalue reference to anything
 49 | struct ubiq_rref_constructor {
 50 |     std::size_t ignore;
 51 |     template <class Type> /*constexpr*/ operator Type() const && noexcept {  // Allows initialization of rvalue reference fields and move-only types
 52 |         return detail::unsafe_declval<Type>();
 53 |     }
 54 | };
 55 | 
 56 | ///////////////////// Hand-made is_complete<T> trait
 57 | template <typename T, typename = void>
 58 | struct is_complete : std::false_type
 59 | {};
 60 | 
 61 | template <typename T>
 62 | struct is_complete<T, decltype(void(sizeof(T)))> : std::integral_constant<bool, true>
 63 | {};
 64 | 
 65 | #ifndef __cpp_lib_is_aggregate
 66 | ///////////////////// Hand-made is_aggregate_initializable_n<T> trait
 67 | 
 68 | // Structure that can be converted to reference to anything except reference to T
 69 | template <class T, bool IsCopyConstructible>
 70 | struct ubiq_constructor_except {
 71 |     std::size_t ignore;
 72 |     template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&> () const noexcept; // Undefined
 73 | };
 74 | 
 75 | template <class T>
 76 | struct ubiq_constructor_except<T, false> {
 77 |     std::size_t ignore;
 78 |     template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&&> () const noexcept; // Undefined
 79 | };
 80 | 
 81 | 
 82 | // `std::is_constructible<T, ubiq_constructor_except<T>>` consumes a lot of time, so we made a separate lazy trait for it.
 83 | template <std::size_t N, class T> struct is_single_field_and_aggregate_initializable: std::false_type {};
 84 | template <class T> struct is_single_field_and_aggregate_initializable<1, T>: std::integral_constant<
 85 |     bool, !std::is_constructible<T, ubiq_constructor_except<T, std::is_copy_constructible<T>::value>>::value
 86 | > {};
 87 | 
 88 | // Hand-made is_aggregate<T> trait:
 89 | // Before C++20 aggregates could be constructed from `decltype(ubiq_?ref_constructor{I})...` but type traits report that
 90 | // there's no constructor from `decltype(ubiq_?ref_constructor{I})...`
 91 | // Special case for N == 1: `std::is_constructible<T, ubiq_?ref_constructor>` returns true if N == 1 and T is copy/move constructible.
 92 | template <class T, std::size_t N, class /*Enable*/ = void>
 93 | struct is_aggregate_initializable_n {
 94 |     static constexpr bool value =
 95 |            std::is_empty<T>::value
 96 |         || std::is_array<T>::value
 97 |     ;
 98 | };
 99 | 
100 | template <class T, std::size_t N>
101 | struct is_aggregate_initializable_n<T, N, std::enable_if_t<std::is_class<T>::value && !std::is_empty<T>::value>> {
102 |     template <std::size_t ...I>
103 |     static constexpr bool is_not_constructible_n(std::index_sequence<I...>) noexcept {
104 |         return (!std::is_constructible<T, decltype(ubiq_lref_constructor{I})...>::value && !std::is_constructible<T, decltype(ubiq_rref_constructor{I})...>::value)
105 |             || is_single_field_and_aggregate_initializable<N, T>::value
106 |         ;
107 |     }
108 | 
109 |     static constexpr bool value = is_not_constructible_n(detail::make_index_sequence<N>{});
110 | };
111 | 
112 | #endif // #ifndef __cpp_lib_is_aggregate
113 | 
114 | ///////////////////// Detect aggregates with inheritance
115 | template <class Derived, class U>
116 | constexpr bool static_assert_non_inherited() noexcept {
117 |     static_assert(
118 |             !std::is_base_of<U, Derived>::value,
119 |             "====================> Boost.PFR: Boost.PFR: Inherited types are not supported."
120 |     );
121 |     return true;
122 | }
123 | 
124 | template <class Derived>
125 | struct ubiq_lref_base_asserting {
126 |     template <class Type> constexpr operator Type&() const &&  // tweak for template_unconstrained.cpp like cases
127 |         noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
128 |     {
129 |         return detail::unsafe_declval<Type&>();
130 |     }
131 | 
132 |     template <class Type> constexpr operator Type&() const &  // tweak for optional_chrono.cpp like cases
133 |         noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
134 |     {
135 |         return detail::unsafe_declval<Type&>();
136 |     }
137 | };
138 | 
139 | template <class Derived>
140 | struct ubiq_rref_base_asserting {
141 |     template <class Type> /*constexpr*/ operator Type() const &&  // Allows initialization of rvalue reference fields and move-only types
142 |         noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
143 |     {
144 |         return detail::unsafe_declval<Type>();
145 |     }
146 | };
147 | 
148 | template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = std::enable_if_t<std::is_copy_constructible<T>::value>>
149 | constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
150 |     -> std::add_pointer_t<decltype(T{ ubiq_lref_base_asserting<T>{}, ubiq_lref_constructor{I}... })>
151 | {
152 |     return nullptr;
153 | }
154 | 
155 | template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = std::enable_if_t<!std::is_copy_constructible<T>::value>>
156 | constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
157 |     -> std::add_pointer_t<decltype(T{ ubiq_rref_base_asserting<T>{}, ubiq_rref_constructor{I}... })>
158 | {
159 |     return nullptr;
160 | }
161 | 
162 | template <class T>
163 | constexpr void* assert_first_not_base(std::index_sequence<>) noexcept
164 | {
165 |     return nullptr;
166 | }
167 | 
168 | template <class T, std::size_t N>
169 | constexpr void assert_first_not_base(int) noexcept {}
170 | 
171 | template <class T, std::size_t N>
172 | constexpr auto assert_first_not_base(long) noexcept
173 |     -> std::enable_if_t<std::is_class<T>::value>
174 | {
175 |     detail::assert_first_not_base<T>(detail::make_index_sequence<N>{});
176 | }
177 | 
178 | ///////////////////// Helpers for initializable detection
179 | // Note that these take O(N) compile time and memory!
180 | template <class T, std::size_t... I, class /*Enable*/ = std::enable_if_t<std::is_copy_constructible<T>::value>>
181 | constexpr auto enable_if_initializable_helper(std::index_sequence<I...>) noexcept
182 |     -> std::add_pointer_t<decltype(T{ubiq_lref_constructor{I}...})>;
183 | 
184 | template <class T, std::size_t... I, class /*Enable*/ = std::enable_if_t<!std::is_copy_constructible<T>::value>>
185 | constexpr auto enable_if_initializable_helper(std::index_sequence<I...>) noexcept
186 |     -> std::add_pointer_t<decltype(T{ubiq_rref_constructor{I}...})>;
187 | 
188 | template <class T, std::size_t N, class U = std::size_t, class /*Enable*/ = decltype(detail::enable_if_initializable_helper<T>(detail::make_index_sequence<N>()))>
189 | using enable_if_initializable_helper_t = U;
190 | 
191 | template <class T, std::size_t N>
192 | constexpr auto is_initializable(long) noexcept
193 |     -> detail::enable_if_initializable_helper_t<T, N, bool>
194 | {
195 |     return true;
196 | }
197 | 
198 | template <class T, std::size_t N>
199 | constexpr bool is_initializable(int) noexcept {
200 |     return false;
201 | }
202 | 
203 | ///////////////////// Helpers for range size detection
204 | template <std::size_t Begin, std::size_t Last>
205 | using is_one_element_range = std::integral_constant<bool, Begin == Last>;
206 | 
207 | using multi_element_range = std::false_type;
208 | using one_element_range = std::true_type;
209 | 
210 | ///////////////////// Fields count next expected compiler limitation
211 | constexpr std::size_t fields_count_compiler_limitation_next(std::size_t n) noexcept {
212 | #if defined(_MSC_VER) && (_MSC_VER <= 1920)
213 |     if (n < 1024)
214 |         return 1024;
215 | #else
216 |     static_cast<void>(n);
217 | #endif
218 |     return (std::numeric_limits<std::size_t>::max)();
219 | }
220 | 
221 | ///////////////////// Fields count upper bound based on sizeof(T)
222 | template <class T>
223 | constexpr std::size_t fields_count_upper_bound_loose() noexcept {
224 |     return sizeof(T) * std::numeric_limits<unsigned char>::digits + 1 /* +1 for "Arrays of Length Zero" extension */;
225 | }
226 | 
227 | ///////////////////// Fields count binary search.
228 | // Template instantiation: depth is O(log(result)), count is O(log(result)), cost is O(result * log(result)).
229 | template <class T, std::size_t Begin, std::size_t Last>
230 | constexpr std::size_t fields_count_binary_search(detail::one_element_range, long) noexcept {
231 |     static_assert(
232 |         Begin == Last,
233 |         "====================> Boost.PFR: Internal logic error."
234 |     );
235 |     return Begin;
236 | }
237 | 
238 | template <class T, std::size_t Begin, std::size_t Last>
239 | constexpr std::size_t fields_count_binary_search(detail::multi_element_range, int) noexcept;
240 | 
241 | template <class T, std::size_t Begin, std::size_t Last>
242 | constexpr auto fields_count_binary_search(detail::multi_element_range, long) noexcept
243 |     -> detail::enable_if_initializable_helper_t<T, (Begin + Last + 1) / 2>
244 | {
245 |     constexpr std::size_t next_v = (Begin + Last + 1) / 2;
246 |     return detail::fields_count_binary_search<T, next_v, Last>(detail::is_one_element_range<next_v, Last>{}, 1L);
247 | }
248 | 
249 | template <class T, std::size_t Begin, std::size_t Last>
250 | constexpr std::size_t fields_count_binary_search(detail::multi_element_range, int) noexcept {
251 |     constexpr std::size_t next_v = (Begin + Last + 1) / 2 - 1;
252 |     return detail::fields_count_binary_search<T, Begin, next_v>(detail::is_one_element_range<Begin, next_v>{}, 1L);
253 | }
254 | 
255 | template <class T, std::size_t Begin, std::size_t N>
256 | constexpr std::size_t fields_count_upper_bound(int, int) noexcept {
257 |     return N - 1;
258 | }
259 | 
260 | template <class T, std::size_t Begin, std::size_t N>
261 | constexpr auto fields_count_upper_bound(long, long) noexcept
262 |     -> std::enable_if_t<(N > detail::fields_count_upper_bound_loose<T>()), std::size_t>
263 | {
264 |     static_assert(
265 |         !detail::is_initializable<T, detail::fields_count_upper_bound_loose<T>() + 1>(1L),
266 |         "====================> Boost.PFR: Types with user specified constructors (non-aggregate initializable types) are not supported.");
267 |     return detail::fields_count_upper_bound_loose<T>();
268 | }
269 | 
270 | template <class T, std::size_t Begin, std::size_t N>
271 | constexpr auto fields_count_upper_bound(long, int) noexcept
272 |     -> detail::enable_if_initializable_helper_t<T, N>
273 | {
274 |     constexpr std::size_t next_optimal = Begin + (N - Begin) * 2;
275 |     constexpr std::size_t next = detail::min_of_size_t(next_optimal, detail::fields_count_compiler_limitation_next(N));
276 |     return detail::fields_count_upper_bound<T, Begin, next>(1L, 1L);
277 | }
278 | 
279 | ///////////////////// Fields count lower bound linear search.
280 | // Template instantiation: depth is O(log(result)), count is O(result), cost is O(result^2).
281 | template <class T, std::size_t Begin, std::size_t Last, class RangeSize, std::size_t Result>
282 | constexpr std::size_t fields_count_lower_bound(RangeSize, size_t_<Result>) noexcept {
283 |     return Result;
284 | }
285 | 
286 | template <class T, std::size_t Begin, std::size_t Last>
287 | constexpr std::size_t fields_count_lower_bound(detail::one_element_range, size_t_<0> = {}) noexcept {
288 |     static_assert(
289 |         Begin == Last,
290 |         "====================> Boost.PFR: Internal logic error."
291 |     );
292 |     return detail::is_initializable<T, Begin>(1L) ? Begin : 0;
293 | }
294 | 
295 | template <class T, std::size_t Begin, std::size_t Last>
296 | constexpr std::size_t fields_count_lower_bound(detail::multi_element_range, size_t_<0> = {}) noexcept {
297 |     // Binary partition to limit template depth.
298 |     constexpr std::size_t middle = Begin + (Last - Begin) / 2;
299 |     constexpr std::size_t result_maybe = detail::fields_count_lower_bound<T, Begin, middle>(
300 |         detail::is_one_element_range<Begin, middle>{}
301 |     );
302 |     return detail::fields_count_lower_bound<T, middle + 1, Last>(
303 |         detail::is_one_element_range<middle + 1, Last>{},
304 |         size_t_<result_maybe>{}
305 |     );
306 | }
307 | 
308 | template <class T, std::size_t Begin, std::size_t Result>
309 | constexpr std::size_t fields_count_lower_bound_unbounded(int, size_t_<Result>) noexcept {
310 |     return Result;
311 | }
312 | 
313 | template <class T, std::size_t Begin>
314 | constexpr auto fields_count_lower_bound_unbounded(long, size_t_<0>) noexcept
315 |     -> std::enable_if_t<(Begin >= detail::fields_count_upper_bound_loose<T>()), std::size_t>
316 | {
317 |     static_assert(
318 |         detail::is_initializable<T, detail::fields_count_upper_bound_loose<T>()>(1L),
319 |         "====================> Boost.PFR: Type must be aggregate initializable.");
320 |     return detail::fields_count_upper_bound_loose<T>();
321 | }
322 | 
323 | template <class T, std::size_t Begin>
324 | constexpr std::size_t fields_count_lower_bound_unbounded(int, size_t_<0>) noexcept {
325 |     constexpr std::size_t last = detail::min_of_size_t(Begin * 2, detail::fields_count_upper_bound_loose<T>()) - 1;
326 |     constexpr std::size_t result_maybe = detail::fields_count_lower_bound<T, Begin, last>(
327 |         detail::is_one_element_range<Begin, last>{}
328 |     );
329 |     return detail::fields_count_lower_bound_unbounded<T, last + 1>(1L, size_t_<result_maybe>{});
330 | }
331 | 
332 | ///////////////////// Choosing between array size, unbounded binary search, and linear search followed by unbounded binary search.
333 | template <class T>
334 | constexpr auto fields_count_dispatch(long, long, std::false_type /*are_preconditions_met*/) noexcept {
335 |     return 0;
336 | }
337 | 
338 | template <class T>
339 | constexpr auto fields_count_dispatch(long, long, std::true_type /*are_preconditions_met*/) noexcept
340 |     -> std::enable_if_t<std::is_array<T>::value, std::size_t>
341 | {
342 |     return sizeof(T) / sizeof(std::remove_all_extents_t<T>);
343 | }
344 | 
345 | template <class T>
346 | constexpr auto fields_count_dispatch(long, int, std::true_type /*are_preconditions_met*/) noexcept
347 |     -> decltype(sizeof(T{}))
348 | {
349 |     constexpr std::size_t typical_fields_count = 4;
350 |     constexpr std::size_t last = detail::fields_count_upper_bound<T, typical_fields_count / 2, typical_fields_count>(1L, 1L);
351 |     return detail::fields_count_binary_search<T, 0, last>(detail::is_one_element_range<0, last>{}, 1L);
352 | }
353 | 
354 | template <class T>
355 | constexpr std::size_t fields_count_dispatch(int, int, std::true_type /*are_preconditions_met*/) noexcept {
356 |     // T is not default aggregate initializable. This means that at least one of the members is not default-constructible.
357 |     // Use linear search to find the smallest valid initializer, after which we unbounded binary search for the largest.
358 |     constexpr std::size_t begin = detail::fields_count_lower_bound_unbounded<T, 1>(1L, size_t_<0>{});
359 | 
360 |     constexpr std::size_t last = detail::fields_count_upper_bound<T, begin, begin + 1>(1L, 1L);
361 |     return detail::fields_count_binary_search<T, begin, last>(detail::is_one_element_range<begin, last>{}, 1L);
362 | }
363 | 
364 | ///////////////////// Returns fields count
365 | template <class T>
366 | constexpr std::size_t fields_count() noexcept {
367 |     using type = std::remove_cv_t<T>;
368 | 
369 |     constexpr bool type_is_complete = detail::is_complete<type>::value;
370 |     static_assert(
371 |         type_is_complete,
372 |         "====================> Boost.PFR: Type must be complete."
373 |     );
374 | 
375 |     constexpr bool type_is_not_a_reference = !std::is_reference<type>::value
376 |          || !type_is_complete // do not show assert if previous check failed
377 |     ;
378 |     static_assert(
379 |         type_is_not_a_reference,
380 |         "====================> Boost.PFR: Attempt to get fields count on a reference. This is not allowed because that could hide an issue and different library users expect different behavior in that case."
381 |     );
382 | 
383 | #if PFR_HAS_GUARANTEED_COPY_ELISION
384 |     constexpr bool type_fields_are_move_constructible = true;
385 | #else
386 |     constexpr bool type_fields_are_move_constructible =
387 |         std::is_copy_constructible<std::remove_all_extents_t<type>>::value || (
388 |             std::is_move_constructible<std::remove_all_extents_t<type>>::value
389 |             && std::is_move_assignable<std::remove_all_extents_t<type>>::value
390 |         )
391 |         || !type_is_not_a_reference // do not show assert if previous check failed
392 |     ;
393 |     static_assert(
394 |         type_fields_are_move_constructible,
395 |         "====================> Boost.PFR: Type and each field in the type must be copy constructible (or move constructible and move assignable)."
396 |     );
397 | #endif  // #if !PFR_HAS_GUARANTEED_COPY_ELISION
398 | 
399 |     constexpr bool type_is_not_polymorphic = !std::is_polymorphic<type>::value;
400 |     static_assert(
401 |         type_is_not_polymorphic,
402 |         "====================> Boost.PFR: Type must have no virtual function, because otherwise it is not aggregate initializable."
403 |     );
404 | 
405 | #ifdef __cpp_lib_is_aggregate
406 |     constexpr bool type_is_aggregate =
407 |         std::is_aggregate<type>::value             // Does not return `true` for built-in types.
408 |         || std::is_scalar<type>::value;
409 |     static_assert(
410 |         type_is_aggregate,
411 |         "====================> Boost.PFR: Type must be aggregate initializable."
412 |     );
413 | #else
414 |     constexpr bool type_is_aggregate = true;
415 | #endif
416 | 
417 | // Can't use the following. See the non_std_layout.cpp test.
418 | //#if !PFR_USE_CPP17
419 | //    static_assert(
420 | //        std::is_standard_layout<type>::value,   // Does not return `true` for structs that have non standard layout members.
421 | //        "Type must be aggregate initializable."
422 | //    );
423 | //#endif
424 | 
425 |     constexpr bool no_errors =
426 |         type_is_complete && type_is_not_a_reference && type_fields_are_move_constructible
427 |         && type_is_not_polymorphic && type_is_aggregate;
428 | 
429 |     constexpr std::size_t result = detail::fields_count_dispatch<type>(1L, 1L, std::integral_constant<bool, no_errors>{});
430 | 
431 |     detail::assert_first_not_base<type, result>(1L);
432 | 
433 | #ifndef __cpp_lib_is_aggregate
434 |     constexpr bool type_is_aggregate_initializable_n =
435 |         detail::is_aggregate_initializable_n<type, result>::value  // Does not return `true` for built-in types.
436 |         || std::is_scalar<type>::value;
437 |     static_assert(
438 |         type_is_aggregate_initializable_n,
439 |         "====================> Boost.PFR: Types with user specified constructors (non-aggregate initializable types) are not supported."
440 |     );
441 | #else
442 |     constexpr bool type_is_aggregate_initializable_n = true;
443 | #endif
444 | 
445 |     static_assert(
446 |         result != 0 || std::is_empty<type>::value || std::is_fundamental<type>::value || std::is_reference<type>::value || !no_errors || !type_is_aggregate_initializable_n,
447 |         "====================> Boost.PFR: If there's no other failed static asserts then something went wrong. Please report this issue to the github along with the structure you're reflecting."
448 |     );
449 | 
450 |     return result;
451 | }
452 | 
453 | }} // namespace pfr::detail
454 | 
455 | #ifdef __clang__
456 | #   pragma clang diagnostic pop
457 | #endif
458 | 
459 | #endif // PFR_DETAIL_FIELDS_COUNT_HPP
460 | 


--------------------------------------------------------------------------------