Fix missing include for unique_ptr. (#125)

Always define is_implicitly_reflectable

.github/workflows/ci.yml

@@ -0,0 +1,183 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+          - toolset: gcc-9  # Do not remove! It is the only toolset that tests misc/strip_boost_namespace.sh
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
+            linkflags: "linkflags=--coverage -lasan -lubsan"
+            gcov_tool: "gcov-10"
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            cxxflags: "cxxflags=-fsanitize=address,undefined,integer -fno-sanitize-recover=undefined"
+            linkflags: "linkflags=-fsanitize=address,undefined,integer"
+          # To low quota to use
+          #- toolset: clang
+          #  cxxstd: "03,11,14,17,2a"
+          #  os: macos-10.15
+          #  cxxflags: "cxxflags=-fsanitize=address,undefined -fno-sanitize-recover=undefined"
+          #  linkflags: "linkflags=-fsanitize=address,undefined"
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=pfr  # Note: changed from ${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 10 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          git submodule update --init --depth 10 --jobs 2 tools/boostdep tools/inspect libs/filesystem
+          python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 3" filesystem
+          rm -rf libs/$LIBRARY/*
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--depth 10 --jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+          ./b2 -j4 variant=debug tools/inspect/build
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release "${{matrix.cxxflags}}" "${{matrix.linkflags}}" "${{matrix.launcher}}"
+          dist/bin/inspect libs/$LIBRARY
+
+      - name: Test boost namespace stripping
+        if: ${{matrix.toolset == 'gcc-9'}}
+        run: ../boost-root/libs/$LIBRARY/misc/strip_boost_namespace.sh
+
+      - name: Prepare coverage data
+        if: matrix.gcov_tool
+        run: |
+          mkdir -p $GITHUB_WORKSPACE/coveralls
+
+          echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
+          chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
+          wget https://github.com/linux-test-project/lcov/archive/v1.15.zip
+          unzip v1.15.zip
+          LCOV="`pwd`/lcov-1.15/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"
+
+          echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info"
+          $LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info
+          $LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info "/usr*" "*/$LIBRARY/test/*" ${{matrix.ignore_coverage}} "*/$LIBRARY/tests/*" "*/$LIBRARY/examples/*" "*/$LIBRARY/example/*" -o $GITHUB_WORKSPACE/coveralls/coverage.info
+
+          cd ../boost-root
+          OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$LIBRARY\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
+          echo $OTHER_LIBS
+          eval "$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info $OTHER_LIBS -o $GITHUB_WORKSPACE/coveralls/coverage.info"
+
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        if: matrix.gcov_tool
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path-to-lcov: ./coveralls/coverage.info
+          parallel: true
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # TODO: fails the loophole tests
+          #- toolset: msvc
+          #  cxxstd: "14,17,latest"
+          #  addrmd: 32,64
+          #  os: windows-2022
+          # TODO: fails the loophole tests
+          #- toolset: msvc-14.2
+          #  cxxstd: "14,17,latest"
+          #  addrmd: 32,64
+          #  os: windows-2019
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          set LIBRARY=pfr
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+
+  finish:
+    needs: posix
+    runs-on: ubuntu-latest
+    steps:
+    - name: Coveralls Finished
+      uses: coverallsapp/github-action@master
+      with:
+        github-token: ${{ secrets.github_token }}
+        parallel-finished: true

.travis.yml

@@ -1,174 +0,0 @@
-# Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-# Copyright Antony Polukhin 2014-2019.
-
-#
-# See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
-# and how it can be used with Boost libraries.
-#
-# File revision #9 (with DIFF)
-
-sudo: false
-language: cpp
-os: linux
-
-env:
-  global:
-    # Autodetect Boost branch by using the following code: - BOOST_BRANCH=$TRAVIS_BRANCH
-    # or just directly specify it
-    - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-
-    # Files, which coverage results must be ignored (files from other projects).
-    # Example: - IGNORE_COVERAGE='*/boost/progress.hpp */filesystem/src/*'
-    - IGNORE_COVERAGE=''
-
-    # Explicitly remove the following library from Boost. This may be useful, if you're for example running Travis
-    # from `Boost.DLL` repo, while Boost already has `dll`.
-    #
-    # By default is eaual to - BOOST_REMOVE=$(basename $TRAVIS_BUILD_DIR)
-    # This will force to use local repo content, instead of the Boost's default.
-    - BOOST_REMOVE=$(basename $TRAVIS_BUILD_DIR)
-
-    # Global options for sanitizers
-    - UBSAN_OPTIONS=print_stacktrace=1
-    - LSAN_OPTIONS=verbosity=1:log_threads=1
-
-# `--coverage` flags required to generate coverage info for Coveralls
-matrix:
-  include:
-#    - env: B2_ARGS='cxxstd=14,1y toolset=gcc-6 cxxflags="--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD -fno-rtti" linkflags="--coverage -lasan -lubsan"'
-#      name: "GCC-6, no RTTI"
-#      addons:
-#        apt:
-#          sources: ubuntu-toolchain-r-test
-#          packages: g++-6
-
-    - env: B2_ARGS='cxxstd=14,17,2a toolset=gcc-8 cxxflags="--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD" linkflags="--coverage  -lasan -lubsan"'
-      name: "GCC-8"
-      sudo: required # Required by leak sanitizer
-      addons:
-        apt:
-          sources: ubuntu-toolchain-r-test
-          packages: g++-8
-
-    - env: B2_ARGS='cxxstd=1y toolset=gcc-5 cxxflags="--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD" linkflags="--coverage  -lasan -lubsan"'
-      name: "GCC-5"
-      addons:
-        apt:
-          sources: ubuntu-toolchain-r-test
-          packages: g++-5
-
-#    - env: B2_ARGS='cxxstd=14,1y toolset=gcc-8 cxxflags="--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD -fno-exceptions" linkflags="--coverage -lasan -lubsan"'
-#      name: "GCC-8, no exceptions"
-#      sudo: required # Required by leak sanitizer
-#      addons:
-#        apt:
-#          sources: ubuntu-toolchain-r-test
-#          packages: g++-8
-
-    - env: B2_ARGS='cxxstd=14 toolset=clang-6 cxxflags="--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD" linkflags="--coverage -fsanitize=address,leak,undefined"'
-      name: "Clang-6"
-      sudo: required # Required by leak sanitizer
-      addons:
-        apt:
-          sources: llvm-toolchain-trusty-6
-          packages: clang-6.0
-
-    - env: B2_ARGS='cxxstd=14,1z toolset=clang-8 cxxflags="-stdlib=libc++ --coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined -DBOOST_TRAVISCI_BUILD" linkflags="-stdlib=libc++ --coverage -fsanitize=address,leak,undefined"'
-      name: "Clang-8, libc++"
-      sudo: required # Required by leak sanitizer
-      addons:
-        apt:
-          sources: llvm-toolchain-trusty-8
-          packages:
-            - clang-8
-            - libc++-8-dev
-            - libc++abi-8-dev
-
-    # Sanitizers disabled for this toolset as they started causing link troubles: 
-    # hidden symbol `_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE11__recommendEm' isn't defined
-    - env: B2_ARGS='cxxstd=14 toolset=clang-libc++ cxxflags="--coverage -DBOOST_TRAVISCI_BUILD" linkflags="--coverage"'
-      name: "Clang-3.8, libc++"
-      addons:
-        apt:
-          packages: libc++-dev
-
-###############################################################################################################
-# From this point and below code is same for all the Boost libs
-###############################################################################################################
-
-# Installing additional tools
-addons:
-  apt:
-    sources: git-core
-    packages:
-    - git
-    - python-yaml
-
-before_install:
-  # Set this to the name of the library
-  - PROJECT_TO_TEST=`basename $TRAVIS_BUILD_DIR`
-
-  # Cloning minimal set of Boost libraries
-  - BOOST=$HOME/boost-local
-  - echo "Testing $PROJECT_TO_TEST, to remove $BOOST/libs/$BOOST_REMOVE, testing branch $BOOST_BRANCH"
-  - git clone -b $BOOST_BRANCH --depth 10 https://github.com/boostorg/boost.git $BOOST
-  - cd $BOOST
-  - git submodule update --init --depth 10 tools/build tools/boostdep libs/type_index # DIFF: Added libs/type_index
-
-  # Replacing Boost module with this project and installing Boost dependencies
-  - rm -rf $BOOST/libs/$BOOST_REMOVE
-  - mv $TRAVIS_BUILD_DIR $BOOST/libs/$PROJECT_TO_TEST
-  - TRAVIS_BUILD_DIR=$BOOST/libs/$PROJECT_TO_TEST
-  - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" $(basename $TRAVIS_BUILD_DIR)
-  - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" type_index  # DIFF: Added line
-  - git status
-
-  # Adding missing toolsets and preparing Boost headers
-  - ./bootstrap.sh
-  - ./b2 headers
-  - |-
-    echo "using gcc ;" >> ~/user-config.jam
-    echo "using clang ;" >> ~/user-config.jam
-    echo "using clang : 3.8 : clang++-3.8 ;" >> ~/user-config.jam
-    echo "using clang : 4 : clang++-4.0 ;" >> ~/user-config.jam
-    echo "using clang : 5 : clang++-5.0 ;" >> ~/user-config.jam
-    echo "using clang : 6 : clang++-6.0 ;" >> ~/user-config.jam
-    echo "using clang : 7 : clang++-7.0 ;" >> ~/user-config.jam
-    echo "using clang : 8 : clang++-8 ;" >> ~/user-config.jam
-    echo "using clang : libc++ : clang++-libc++ ;" >> ~/user-config.jam
-  - cd $BOOST/libs/$PROJECT_TO_TEST/test/
-
-script:
-  - sh -c "../../../b2 -j2 $B2_ARGS"
-
-after_success:
-  # Copying Coveralls data to a separate folder
-  - mkdir -p $TRAVIS_BUILD_DIR/coverals
-  - find ../../../bin.v2/ -name "*.gcda" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
-  - find ../../../bin.v2/ -name "*.gcno" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
-  - find ../../../bin.v2/ -name "*.da" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
-  - find ../../../bin.v2/ -name "*.no" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
-  - wget https://github.com/linux-test-project/lcov/archive/v1.12.zip
-  - unzip v1.12.zip
-  - LCOV="`pwd`/lcov-1.12/bin/lcov --gcov-tool gcov-6"
-
-  # Preparing Coveralls data by changind data format to a readable one
-  - echo "$LCOV --directory $TRAVIS_BUILD_DIR/coverals --base-directory `pwd` --capture --output-file $TRAVIS_BUILD_DIR/coverals/coverage.info"
-  - $LCOV --directory $TRAVIS_BUILD_DIR/coverals --base-directory `pwd` --capture --output-file $TRAVIS_BUILD_DIR/coverals/coverage.info
-
-  # ... erasing /test/ /example/ folder data
-  - cd $BOOST
-  - $LCOV --remove $TRAVIS_BUILD_DIR/coverals/coverage.info "/usr*" "*/$PROJECT_TO_TEST/test/*" $IGNORE_COVERAGE "*/$PROJECT_TO_TEST/tests/*" "*/$PROJECT_TO_TEST/examples/*" "*/$PROJECT_TO_TEST/example/*" -o $TRAVIS_BUILD_DIR/coverals/coverage.info
-
-  # ... erasing data that is not related to this project directly
-  - OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$PROJECT_TO_TEST\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
-  - echo $OTHER_LIBS
-  - eval "$LCOV --remove $TRAVIS_BUILD_DIR/coverals/coverage.info $OTHER_LIBS -o $TRAVIS_BUILD_DIR/coverals/coverage.info"
-
-  # Sending data to Coveralls
-  - cd $TRAVIS_BUILD_DIR
-  - gem install coveralls-lcov
-  - coveralls-lcov coverals/coverage.info

CMakeLists.txt

@@ -0,0 +1,20 @@
+# Generated by `boostdep --cmake pfr`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_pfr VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_pfr INTERFACE)
+add_library(Boost::pfr ALIAS boost_pfr)
+
+target_include_directories(boost_pfr INTERFACE include)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

LICENSE_1_0.txt

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

README.md

@@ -1,34 +1,43 @@
-# Precise and Flat Reflection (ex Magic Get, ex PODs Flat Reflection)
+# [Boost.PFR](https://boost.org/libs/pfr)
 
-This C++14 library is meant for accessing structure elements by index and providing other std::tuple like methods for user defined types without any macro or boilerplate code.
+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.
 
+[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.
 
-[Latest documentation](http://apolukhin.github.com/magic_get/index.html)
+For a version of the library without `boost::` namespace see [PFR](https://github.com/apolukhin/pfr_non_boost).
 
 ### Test results
 
 Branches        | Build         | Tests coverage | More info
 ----------------|-------------- | -------------- |-----------
-Develop:        | [![Build Status](https://travis-ci.org/apolukhin/magic_get.svg?branch=develop)](https://travis-ci.org/apolukhin/magic_get) [![Build status](https://ci.appveyor.com/api/projects/status/1edm74h5id8qpr2k/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/magic-get/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...](http://www.boost.org/development/tests/develop/developer/pfr.html)) -->
-Master:         | [![Build Status](https://travis-ci.org/apolukhin/magic_get.svg?branch=master)](https://travis-ci.org/apolukhin/magic_get) [![Build status](https://ci.appveyor.com/api/projects/status/1edm74h5id8qpr2k/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/magic-get/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...](http://www.boost.org/development/tests/master/developer/pfr.html)) -->
+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://www.boost.org/development/tests/develop/developer/pfr.html)
+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://www.boost.org/development/tests/master/developer/pfr.html)
+
+[Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html)
 
 ### Motivating Example #0
 ```c++
-// requires: C++14
 #include <iostream>
+#include <fstream>
 #include <string>
-#include "boost/pfr/precise.hpp"
+
+#include "boost/pfr.hpp"
 
 struct some_person {
-    std::string name;
-    unsigned birth_year;
+  std::string name;
+  unsigned birth_year;
 };
 
-int main() {
-    some_person val{"Edgar Allan Poe", 1809};
+int main(int argc, const char* argv[]) {
+  some_person val{"Edgar Allan Poe", 1809};
 
-    std::cout << boost::pfr::get<0>(val)                // No macro!
-        << " was born in " << boost::pfr::get<1>(val);  // Works with any aggregate initializables!
+  std::cout << boost::pfr::get<0>(val)                // No macro!
+      << " was born in " << boost::pfr::get<1>(val);  // Works with any aggregate initializables!
+
+  if (argc > 1) {
+    std::ofstream ofs(argv[1]);
+    ofs << boost::pfr::io(val);                       // File now contains: {"Edgar Allan Poe", 1809}
+  }
 }
 ```
 Outputs:
@@ -36,12 +45,13 @@ Outputs:
 Edgar Allan Poe was born in 1809
 ```
 
+[Run the above sample](https://godbolt.org/z/PfYsWKb7v)
+
 
 ### Motivating Example #1
 ```c++
-// requires: C++14
 #include <iostream>
-#include "boost/pfr/precise.hpp"
+#include "boost/pfr.hpp"
 
 struct my_struct { // no ostream operator defined!
     int i;
@@ -50,11 +60,9 @@ struct my_struct { // no ostream operator defined!
 };
 
 int main() {
-    using namespace boost::pfr::ops; // out-of-the-box ostream operator for all PODs!
-
     my_struct s{100, 'H', 3.141593};
     std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
-        << " fields: " << s << "\n";
+        << " fields: " << boost::pfr::io(s) << "\n";
 }
 
 ```
@@ -67,9 +75,8 @@ my_struct has 3 fields: {100, H, 3.14159}
 ### Motivating Example #2
 
 ```c++
-// requires: C++14
 #include <iostream>
-#include "boost/pfr/precise.hpp"
+#include "boost/pfr.hpp"
 
 struct my_struct { // no ostream operator defined!
     std::string s;
@@ -77,11 +84,9 @@ struct my_struct { // no ostream operator defined!
 };
 
 int main() {
-    using namespace boost::pfr::ops; // out-of-the-box ostream operators for aggregate initializables!
-
     my_struct s{{"Das ist fantastisch!"}, 100};
     std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
-        << " fields: " << s << "\n";
+        << " fields: " << boost::pfr::io(s) << "\n";
 }
 
 ```
@@ -91,14 +96,63 @@ Outputs:
 my_struct has 2 fields: {"Das ist fantastisch!", 100}
 ```
 
+### Motivating Example #3
+
+```c++
+#include <iostream>
+#include <string>
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/fusion/include/adapt_boost_pfr.hpp>
+
+#include "boost/pfr/io.hpp"
+
+namespace x3 = boost::spirit::x3;
+
+struct ast_employee { // No BOOST_FUSION_ADAPT_STRUCT defined
+    int age;
+    std::string forename;
+    std::string surname;
+    double salary;
+};
+
+auto const quoted_string = x3::lexeme['"' >> +(x3::ascii::char_ - '"') >> '"'];
+
+x3::rule<class employee, ast_employee> const employee = "employee";
+auto const employee_def =
+    x3::lit("employee")
+    >> '{'
+    >>  x3::int_ >> ','
+    >>  quoted_string >> ','
+    >>  quoted_string >> ','
+    >>  x3::double_
+    >>  '}'
+    ;
+BOOST_SPIRIT_DEFINE(employee);
+
+int main() {
+    std::string str = R"(employee{34, "Chip", "Douglas", 2500.00})";
+    ast_employee emp;
+    x3::phrase_parse(str.begin(),
+                     str.end(),
+                     employee,
+                     x3::ascii::space,
+                     emp);
+    std::cout << boost::pfr::io(emp) << std::endl;
+}
+
+```
+Outputs:
+```
+(34 Chip Douglas 2500)
+```
+
 
 ### Requirements and Limitations
 
-General:
-* C++14 compatible compiler (GCC-5.0+, Clang, Visual Studio 2017 with /std:c++latest or /std:c++17, ...)
-* Static variables are ignored
-* T must be constexpr aggregate initializable and must not contain references nor bitfields
+[See docs](https://www.boost.org/doc/libs/develop/doc/html/boost_pfr.html).
 
 ### License
 
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
+Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).

doc/Jamfile.v2

@@ -30,50 +30,31 @@ local doxygen_params =
         <doxygen:param>INLINE_SIMPLE_STRUCTS=YES
         <doxygen:param>SORT_MEMBER_DOCS=NO
         <doxygen:param>"ALIASES= \\
-            \"flattening{1}=\\xmlonly<link linkend='boost_precise_and_flat_reflectio.tutorial.flattening'>\\1</link>\\endxmlonly\" \\
-            \"podops=\\b See \\b Also: \\xmlonly<link linkend='boost_precise_and_flat_reflectio.tutorial.three_ways_of_getting_operators'>Three ways of getting operators</link>\\endxmlonly\" \\
-            \"constexprinit{1}=\\xmlonly<link linkend='boost_precise_and_flat_reflectio.requirements_and_limitations'>\\1</link>\\endxmlonly\" \\
-            \"rcast=\\b Note: If reflecting structures with enums may `reinterpret_cast` enum to a reference to underlying type.\" \\
-            \"flatpod{1}=\\xmlonly<link linkend='boost_precise_and_flat_reflectio.requirements_and_limitations'>\\1</link>\\endxmlonly\" \\
+            \"forcedlink{1}=\\xmlonly<link linkend='boost.pfr.\\1'>\\endxmlonly boost::pfr::\\1\\xmlonly</link>\\endxmlonly\" \\
+            \"podops=\\b See \\b Also : \\xmlonly<link linkend='boost_pfr.tutorial.three_ways_of_getting_operators'>\\endxmlonly 'Three ways of getting operators' \\xmlonly</link>\\endxmlonly\" \\
+            \"customio=\\b See \\b Also : \\xmlonly<link linkend='boost_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.\" \\
+            \"aggregate=\\xmlonly<link linkend='boost_pfr.limitations_and_configuration'>\\endxmlonly simple aggregate \\xmlonly</link>\\endxmlonly\" \\
+        "
+        <doxygen:param>"PREDEFINED= \\
+            \"BOOST_PFR_DOXYGEN_INVOKED=1\" \\
         "
     ;
 
-doxygen autodoc_all
+doxygen autodoc_pfr
     :
         [ glob ../../../boost/pfr.hpp ]
+        [ glob ../../../boost/pfr/*.hpp ]
     :
         $(doxygen_params)
-        <xsl:param>"boost.doxygen.reftitle=Include all"
-    ;
-
-
-doxygen autodoc_flat
-    :
-        [ glob ../../../boost/pfr/flat.hpp ]
-        [ glob ../../../boost/pfr/flat/*.hpp ]
-    :
-        $(doxygen_params)
-        <xsl:param>"boost.doxygen.reftitle=Flat Reflection"
-    ;
-
-
-doxygen autodoc_precise
-    :
-        [ glob ../../../boost/pfr/precise.hpp ]
-        [ glob ../../../boost/pfr/precise/*.hpp ]
-    :
-        $(doxygen_params)
-        <xsl:param>"boost.doxygen.reftitle=Precise Reflection"
+        <xsl:param>"boost.doxygen.reftitle=Reference Section"
     ;
 
 boostbook pfr-doc
     :
         pfr.qbk
     :
-        <dependency>autodoc_all
-        <dependency>autodoc_precise
-        <dependency>autodoc_flat
-        <xsl:param>boost.root=http://www.boost.org/doc/libs/1_63_0
+        <dependency>autodoc_pfr
+        <xsl:param>boost.root=https://www.boost.org/doc/libs/1_81_0
         #<xsl:param>boost.root=../../../.
         <xml:param>html.stylesheet=../../../../doc/src/boostbook.css
     ;

doc/pfr.qbk

@@ -1,7 +1,7 @@
-[library Boost.Precise and Flat Reflection
+[library Boost.PFR
     [quickbook 1.6]
-    [version 1.0]
-    [copyright 2016-2020 Antony Polukhin]
+    [version 2.1]
+    [copyright 2016-2023 Antony Polukhin]
     [category Language Features Emulation]
     [license
         Distributed under the Boost Software License, Version 1.0.
@@ -10,193 +10,419 @@
     ]
 ]
 
-[section Motivation]
+[section Intro]
 
-In C++ we have:
+Boost.PFR is a C++14 library for a very basic reflection. It gives you access to structure elements by index and provides other `std::tuple` like methods for user defined types without macro or boilerplate code:
 
-* tuples - types that provide access to members by index. Those are useful for generic programming.
-* structures - types with named fields that do not provide access to members by index. Those are just easy to use.
+[import ../example/motivating_example0.cpp]
+[pfr_motivating_example]
 
-This library provides tuple like methods for aggregate initializable structures, making them usable in contexts were only tuples were useful.
-
-[note All you have to do is to add `#include <boost/pfr.hpp>`.
-
-No macro or other type/member registrations required.]
+Experiment with the sample [@https://godbolt.org/z/PfYsWKb7v online].
+See [link boost_pfr.limitations_and_configuration [*limitations]].
 
 
-[import ../example/examples.cpp]
+[h2 Usecase example]
 
-The two different types of reflection are:
+Imagine that you are writing the wrapper library for a database. Depending on the usage of Boost.PFR users code will look differently:
 
-* [*Precise] reflection, where each field type is represented as it actually exists, even if the type is itself a user-defined type.
-* [*Flat] reflection, where user-defined types are represented by their individual field types, and all other types are represented as they actually exists.
+[table:hand_made_vs_pfr_1
+[[ Without Boost.PFR ] [ With Boost.PFR ]]
+[[
+```
+#include <db/api.hpp>
 
-As an example:
+struct user_info {
+    std::int64_t id;
+    std::string name, email, login;
+};
 
-[pfr_intro]
+user_info retrieve_friend(std::string_view name) {
+    std::tuple info_tuple
+      = db::one_row_as<std::int64_t, std::string, std::string, std::string>(
+        "SELECT id, name, email, login FROM user_infos WHERE name=$0",
+        name
+    );
+
+    /////////////////////////////////////////////////////////////////////////////
+    user_info info {
+        std::move(std::get<0>(info_tuple)),
+        std::move(std::get<1>(info_tuple)),
+        std::move(std::get<2>(info_tuple)),
+        std::move(std::get<3>(info_tuple)),
+    }
+    /////////////////////////////////////////////////////////////////////////////
+
+    auto friend_info = ask_user_for_friend(std::move(info));
+
+    db::insert(
+        "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)",
+        friend_info.id,    //////////////////////////////////////////////////////
+        friend_info.name,  // Users are forced to enumerate fields because your
+        friend_info.email, // library can not iterate over the fields of a user
+        friend_info.login  // provided structure
+    );
+
+    return friend_info;
+}
+```
+][
+```
+#include <db/api.hpp>
+
+struct user_info {
+    std::int64_t id;
+    std::string name, email, login;
+};
+
+user_info retrieve_friend(std::string_view name) {
+    // With Boost.PFR you can put data directly into user provided structures
+    user_info info = db::one_row_as<user_info>(
+        "SELECT id, name, email, login FROM user_infos WHERE name=$0",
+        name
+    );
+
+    ////////////////// No boilerplate code to move data around //////////////////
 
 
-Boost.Precise and Flat Reflection (Boost.PFR) adds following out-of-the-box functionality for aggregate initializable structures:
 
-* comparison operators
+
+
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    auto friend_info = ask_user_for_friend(std::move(info));
+
+    db::insert(
+        "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)",
+        friend_info     /////////////////////////////////////////////////////////
+                        // Boost.PFR allows you to iterate over all the fields
+                        // of a user provided structure
+                        //
+    );
+
+    return friend_info;
+}
+```
+]]
+]
+
+Otherwise your library could require a customization point for a user type:
+
+
+[table:hand_made_vs_pfr_2
+[[ Without Boost.PFR ] [ With Boost.PFR ]]
+[[
+```
+#include <db/api.hpp>
+
+struct user_info {
+    std::int64_t id;
+    std::string name, email, login;
+};
+
+/// Customizations via hand-written code ////////////////////////////////////////
+auto db_api_tie(user_info& ui) noexcept {
+    return std::tie(ui.id, ui.name, ui.email, ui.login);
+}
+
+auto db_api_tie(const user_info& ui) noexcept {
+    return std::tie(ui.id, ui.name, ui.email, ui.login);
+}
+/////////////////////////////////////////////////////////////////////////////////
+```
+][
+```
+#include <db/api.hpp>
+
+struct user_info {
+    std::int64_t id;
+    std::string name, email, login;
+};
+
+//////// With Boost.PFR there's no need in hand written customizations //////////
+
+
+
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////////
+```
+]]
+]
+
+
+Imagine that you are writing a serialization library. Serialization of user
+provided structures (and nested structures) with Boost.PFR it is just as simple as:
+
+```
+void Write(Writer& writer, int value);
+void Write(Writer& writer, std::string_view value);
+
+template <typename T>
+std::enable_if_t<std::is_aggregate_v<T>> Write(Writer& writer, const T& value) {
+  boost::pfr::for_each_field(
+      value, [&writer](const auto& field) { Write(writer, field); });
+}
+```
+
+With Boost.PFR the code is shorter, more readable and more pleasant to write.
+
+[note All the above examples were inspired by the Boost.PFR usage in [@https://github.com/userver-framework/userver 🐙 userver framework].]
+
+
+[h2 Out of the box functionality ]
+
+Boost.PFR adds the following out-of-the-box functionality for aggregate initializable structures:
+
+* comparison functions
 * heterogeneous comparators
 * hash
-* stream operators
-* access to members by index
-* member reflections
+* IO streaming
+* access to members by index or type
+* member type retrieval
 * methods for cooperation with `std::tuple`
 * methods to visit each field of the structure
+* trait to detect potential ability to reflect type, and ability to override trait's decision in user-side code
 
+Boost.PFR is a header only library that does not depend on Boost. You can just copy the content of the "include" folder [@https://github.com/boostorg/pfr from the Boost.PFR github] into your project, and the library will work fine. For a version of the library without `boost::` namespace see [@https://github.com/apolukhin/pfr_non_boost PFR].
 
-[warning This is not an official Boost library! It wasn't reviewed and can't be downloaded from www.boost.org. This library is available to the community to know real interest and get comments for refinement. The intention is to submit library to formal review, if community think that it is interesting!]
-
-[caution This is a C++14 library! Pre C++14 compilers (C++11, C++03...) are not supported]
+[caution Recommended C++ Standards are C++17 and above. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported]
 
 [endsect]
 
+
+[section Short Examples for the Impatient]
+
+[import ../example/quick_examples.cpp]
+
+
+[table:quick_examples
+[[ Code snippet ] [ Reference: ]]
+[
+    [ [pfr_quick_examples_get] ]
+    [ [funcref boost::pfr::get] ]
+][
+    [ [pfr_quick_examples_ops] ]
+    [
+
+        [headerref boost/pfr/ops.hpp Header boost/pfr/ops.hpp]:
+
+        * [funcref boost::pfr::eq]
+
+        * [funcref boost::pfr::ne]
+
+        * [funcref boost::pfr::gt]
+
+        * ...
+
+    ]
+][
+    [ [pfr_quick_examples_for_each] ]
+    [
+        [funcref boost::pfr::for_each_field]
+
+        [funcref boost::pfr::io]
+    ]
+][
+    [ [pfr_quick_examples_functions_for] ]
+    [ [macroref BOOST_PFR_FUNCTIONS_FOR] ]
+][
+    [ [pfr_quick_examples_eq_fields] ]
+    [
+        [headerref boost/pfr/ops_fields.hpp Header boost/pfr/ops_fields.hpp ]:
+
+        * [funcref boost::pfr::eq_fields]
+
+        * [funcref boost::pfr::ne_fields]
+
+        * [funcref boost::pfr::gt_fields]
+
+        * ...
+
+        [headerref boost/pfr/io_fields.hpp Header boost/pfr/io_fields.hpp ]
+
+        * [funcref boost::pfr::io_fields]
+
+    ]
+][
+    [ [pfr_quick_examples_for_each_idx] ]
+    [ [funcref boost::pfr::for_each_field] ]
+][
+    [ [pfr_quick_examples_tuple_size] ]
+    [ [classref boost::pfr::tuple_size] ]
+][
+    [ [pfr_quick_examples_structure_to_tuple] ]
+    [ [funcref boost::pfr::structure_to_tuple] ]
+][
+    [ [pfr_quick_examples_structure_tie] ]
+    [ [funcref boost::pfr::structure_tie] ]
+]]
+
+
+
+[endsect]
+
+
 [section Tutorial]
 
-[section Accessing POD member by index] [pfr_example_get] [endsect]
-[section Flattening] [pfr_example_flattening] [pfr_example_flattening_2] [endsect]
-[/ [section Counting fields] [pfr_example_tuple_size] [endsect] ]
+[import ../example/sample_printing.cpp]
+[import ../example/get.cpp]
 
-[section Flat or Precise functions to choose]
-All the functions that have `flat_` prefix and are declared in `boost/pfr/flat/*` headers the [*flat] functions, other function are [*precise] and are declared in `boost/pfr/precise/*`. In previous example you've seen how the the flattening works.
 
-* If you wish types flattened - use [*flat] functions
-* If you use types with C arrays - use [*flat] functions
-* Otherwise use [*precise] functions
+[section Why tuples are bad and aggregates are more preferable?]
 
-[warning MSVC currently supports only [*precise] functions and only in /std:c++latest or /std:c++17 modes.]
+`std::tuple` and `std::pair` are good for generic programming, however they have disadvantages. First of all, code that uses them becomes barely readable. Consider two definitions:
+
+[table:tuples_vs_aggregates
+[[ Tuple ] [ Aggregate ]]
+[[
+```
+using auth_info_tuple = std::tuple<
+    std::int64_t, // What does this integer represents?
+    std::int64_t,
+    std::time_t
+>;
+```
+][
+```
+struct auth_info_aggregate {
+    std::int64_t user_id;    // Oh, now I see!
+    std::int64_t session_id;
+    std::time_t  valid_till;
+};
+```
+]]
+]
+
+Definition via aggregate initializable structure is much more clear. Same story with usages: `return std::get<1>(value);` vs. `return value.session_id;`.
+
+Another advantage of aggregates is a more efficient copy, move construction and assignments.
+
+Because of the above issues some guidelines recommend to [*use aggregates instead of tuples]. However aggregates fail when it comes to the functional like programming.
+
+Boost.PFR library [*provides tuple like methods for aggregate initializable structures], making aggregates usable in contexts where only tuples were useful.
 
 [endsect]
 
+[section Accessing structure member by index] [pfr_example_get] [endsect]
+[section Custom printing of aggregates] [pfr_sample_printing] [endsect]
+
 
 [section Three ways of getting operators ]
 
-There are three ways to start using Boost.PFR hashing, comparison and streaming operators for type `T` in your code. Each method has it's own drawbacks and suits own cases.
+There are three ways to start using Boost.PFR hashing, comparison and streaming for type `T` in your code. Each method has its own drawbacks and suits own cases.
 
-[table:flat_ops_comp Different approaches for operators
+[table:ops_comp Different approaches for operators
     [[ Approach
-    ][ Defines operators in global namespace ][ Defined operators could be found by ADL ][ Works for local types ][ Usable localy, without affecting code from other scopes ][ Ignores implicit conversion operators ][ Respects user defined operators ]]
+    ][ When to use
+    ][ Operators could be found by ADL ][ Works for local types ][ Usable locally, without affecting code from other scopes ][ Ignores implicit conversion operators ][ Respects user defined operators ]]
 
     [[
-        [headerref boost/pfr/precise/ops.hpp using\u00A0namespace\u00A0boost::pfr::ops;]
+        [headerref boost/pfr/ops.hpp boost/pfr/ops.hpp: eq, ne, gt, lt, le, ge]
 
-        [headerref boost/pfr/flat/ops.hpp using\u00A0namespace\u00A0boost::pfr::flat_ops;]
-    ][ no ][ no ][ yes ][ yes ][ no ][ yes ]]
+        [headerref boost/pfr/io.hpp boost/pfr/io.hpp: io]
+    ][
+        Use when you need to compare values by provided for them operators or via field-by-field comparison.
+    ][ no ][ yes ][ yes ][ no ][ yes ]]
 
     [[
-        [macroref BOOST_PFR_FLAT_FUNCTIONS_FOR]
-        
-        [macroref BOOST_PFR_PRECISE_FUNCTIONS_FOR]  
-    ][ yes if T is in it ][ yes ][ no ][ no, but could be limited to translation unit ][ yes for T ] [ no (compile time error) ]]
+        [macroref BOOST_PFR_FUNCTIONS_FOR BOOST_PFR_FUNCTIONS_FOR(T)]
+    ][
+        Use near the type definition to define the whole set of operators for your type.
+    ][ yes ][ no ][ no ][ yes for T ] [ no (compile time error) ]]
 
     [[
-        [headerref boost/pfr/flat/global_ops.hpp]
+        [headerref boost/pfr/ops_fields.hpp boost/pfr/ops_fields.hpp: eq_fields, ne_fields, gt_fields, lt_fields, le_fields, ge_fields]
 
-        [headerref boost/pfr/precise/global_ops.hpp]
-    ][ yes ][ yes ][ yes ][ no, but could be limited to translation unit ][ yes all ][ yes ]]
+        [headerref boost/pfr/io.hpp boost/pfr/io_fields.hpp: io_fields]
+    ][
+        Use to implement the required set of operators for your type.
+    ][ no ][ yes ][ yes ][ yes ][ yes ]]
 ]
 
 More detailed description follows:
 
-[*1. [headerref boost/pfr/precise/ops.hpp `using namespace boost::pfr::ops;`] and [headerref boost/pfr/flat/ops.hpp `using namespace boost::pfr::flat_ops;`] approach]
+[*1. `eq, ne, gt, lt, le, ge, io` approach]
 
-This method is good if you're writing generic algorithms and need to use operators from Boost.PFR only if there's no operators defined for the type:
+This method is good if you're writing generic algorithms and need to use operators from Boost.PFR only if there are no operators defined for the type:
 
 ```
-#include <boost/pfr/precise/ops.hpp>
+#include <boost/pfr/ops.hpp>
 
 template <class T>
 struct uniform_comparator_less {
     bool operator()(const T& lhs, const T& rhs) const noexcept {
-        using namespace boost::pfr::ops;    // Enables Boost.PFR operators usage in this scope.
-
-        // If T has operator< or conversion operator then will use it.
-        // Otherwise will use boost::pfr::flat_less<T>.
-        return lhs < rhs;
+        // If T has operator< or conversion operator then it is used.
+        return boost::pfr::lt(lhs, rhs);
     }
 };
 ```
-This method's effects are local to the function. It works even for local types, like structures defined in functions.
-However *Argument Dependant Lookup* does not work with it:
+This methods effects are local to the function. It works even for local types, like structures defined in functions.
 
+
+[*2. BOOST_PFR_FUNCTIONS_FOR(T) approach]
+
+This method is good if you're writing a structure and wish to define operators for that structure.
 ```
-#include <boost/pfr/flat/ops.hpp>
-template <class T>
-struct uniform_comparator_less {
-    bool operator()(const T& lhs, const T& rhs) const noexcept {
-        using namespace flat_ops;
-
-        // Compile time error if T has neither operator< nor
-        // conversion operator to comparable type.
-        return std::less{}(lhs, rhs);
-    }
-};
-```
-
-[*2. [macroref BOOST_PFR_FLAT_FUNCTIONS_FOR] and [macroref BOOST_PFR_PRECISE_FUNCTIONS_FOR] approach]
-
-This method is good if you're writing POD structure and wish to define operators for that structure.
-```
-#include <boost/pfr/flat/functions_for.hpp>
+#include <boost/pfr/functions_for.hpp>
 
 struct pair_like {
     int first;
     short second;
 };
 
-BOOST_PFR_FLAT_FUNCTIONS_FOR(pair_like)   // Defines operators
+BOOST_PFR_FUNCTIONS_FOR(pair_like)   // Defines operators
 
 // ...
 
 assert(pair_like{1, 2} < pair_like{1, 3});
 ```
-Argument Dependant Lookup works well, `std::less` will find the operators for `struct pair_like`. [macroref BOOST_PFR_FLAT_FUNCTIONS_FOR BOOST_PFR_FLAT_FUNCTIONS_FOR(T)]
-can not be used for local types, it must be called only once in namespace of `T`. It does not respect conversion operators of `T`, so for example the following code
+Argument Dependant Lookup works well. `std::less` will find the operators for `struct pair_like`. [macroref BOOST_PFR_FUNCTIONS_FOR BOOST_PFR_FUNCTIONS_FOR(T)]
+can not be used for local types. It does not respect conversion operators of `T`, so for example the following code
 will output different values:
 ```
-#include <boost/pfr/flat/functions_for.hpp>
+#include <boost/pfr/functions_for.hpp>
 
 struct empty {
     operator std::string() { return "empty{}"; }
 };
 // Uncomment to get different output:
-// BOOST_PFR_FLAT_FUNCTIONS_FOR(empty)
+// BOOST_PFR_FUNCTIONS_FOR(empty)
 
 // ...
-std::cout << empty{}; // Outputs `empty{}` if BOOST_PFR_FLAT_FUNCTIONS_FOR(empty) is commented out, '{}' otherwise.
+std::cout << empty{}; // Outputs `empty{}` if BOOST_PFR_FUNCTIONS_FOR(empty) is commented out, '{}' otherwise.
 ```
 
-[*3. [headerref boost/pfr/flat/global_ops.hpp] and [headerref boost/pfr/precise/global_ops.hpp] approach]
+[*3. `eq_fields, ne_fields, gt_fields, lt_fields, le_fields, ge_fields, io_fields` approach]
 
-This approach is for those, who wish to have comparisons/streaming/hashing for all their types.
+This method is good if you're willing to provide only some operators for your type:
 
 ```
-#include <boost/pfr/flat/global_ops.hpp>
+#include <boost/pfr/io_fields.hpp>
 
 struct pair_like {
     int first;
-    short second;
+    std::string second;
 };
 
-// ...
-
-assert(pair_like{1, 2} < pair_like{1, 3});
+inline std::ostream& operator<<(std::ostream& os, const pair_like& x) {
+    return os <<  bost::pfr::io_fields(x);
+}
 ```
-Argument Dependant Lookup works well, `std::less` will find the operators for `struct pair_like`. Operators for local types will be also defined.
-*All conversion operators of all POD types won't be used during comparisons/streaming/hashing.*
+
+All the `*_fields` functions do ignore user defined operators and work only with fields of a type. This makes them perfect for defining you own operators.
 
 [endsect]
 
 
 [section Reflection of unions ]
 
-With [*precise] reflection you could do reflection if a type contains union. But be sure that operations for union are manually defined:
+You could use tuple-like representation if a type contains union. But be sure that operations for union are manually defined:
 
 ```
-#include <boost/pfr/precise/ops.hpp>
+#include <boost/pfr/ops.hpp>
 
 union test_union {
     int i;
@@ -205,18 +431,13 @@ union test_union {
 
 inline bool operator==(test_union l, test_union r) noexcept; // Compile time error without this operator
 
-
-struct foo { int i; test_union u; };
-
-bool some_function(foo f1, foo f2) {
-    using namespace boost::pfr::ops;
-    return f1 == f2; // OK
+bool some_function(test_union f1, test_union f2) {
+    return boost::pfr::eq(f1, f2); // OK
 }
 
 ```
 
-[*Flat] reflection of types that contain unions is disabled.
-[*Flat] and [*precise] reflection of unions is disabled for safety reasons. There's a way to reflect the first member of a union and use it. Unfortunately there's no way to find out [*active] member of a union. Accessing an inactive union member is an Undefined Behavior. Using the first union member for reflection could lead to disaster if it is some character pointer. For example ostreaming `union {char* c; long long ll; } u; u.ll= 1;` will crash your program, as the active member is `ll` that holds `1` but we are trying to output a `char*`. This would cause an invalid pointer2 dereference.
+Reflection of unions is disabled in the Boost.PFR library for safety reasons. Alas, there's no way to find out [*active] member of a union and accessing an inactive member is an Undefined Behavior. For example, library could always return the first member, but ostreaming `u` in `union {char* c; long long ll; } u; u.ll= 1;` will crash your program with an invalid pointer dereference.
 
 Any attempt to reflect unions leads to a compile time error. In many cases a static assert is triggered that outputs the following message:
 
@@ -230,140 +451,57 @@ error: static_assert failed "====================> Boost.PFR: For safety reasons
 [endsect]
 
 
-[section Short Examples for the Impatient]
+[section Limitations and Configuration]
 
-[import ../example/quick_examples.cpp]
+[caution Recommended C++ Standards are C++17 and above. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported. ]
 
-[pfr_quick_examples_structures]
+Boost.PFR library works with types that satisfy the requirements of `SimpleAggregate`: aggregate types without base classes, `const` fields, references, or C arrays:
 
-Following examples use definition from above:
+```
+struct simple_aggregate {  // SimpleAggregate
+    std::string name;
+    int age;
+    boost::uuids::uuid uuid;
+};
 
-[table:quick_examples
-[[ Code snippet ] [ `var` content or output ] [ Function description: ]]
-[
-    [ [pfr_quick_examples_flat_functors_uset] ]
-    [ `my_uset` constains `var` ]
-    [
-        [classref boost::pfr::flat_hash flat_hash]
+struct empty {             // SimpleAggregate
+};
 
-        [classref boost::pfr::flat_equal_to flat_equal_to]
-    ]
-][
-    [ [pfr_quick_examples_flat_functors_set] ]
-    [ `my_set` constains `var` ]
-    [ [classref boost::pfr::flat_less flat_less] ]
-][
-    [ [pfr_quick_examples_flat_ops] ]
-    [ assert succeeds ]
-    [ [headerref boost/pfr/flat/ops.hpp using\u00A0namespace\u00A0flat_ops;] ]
-][
-    [ [pfr_quick_examples_ops] ]
-    [ assert succeeds ]
-    [ [headerref boost/pfr/precise/ops.hpp using\u00A0namespace\u00A0ops;] ]
-][
-    [ [pfr_quick_examples_flat_for_each] ]
-    [ `var == {B, {778, 4.14159}}` ]
-    [ [funcref boost::pfr::flat_for_each_field flat_for_each_field] ]
-][
-    [ [pfr_quick_examples_for_each] ]
-    [ `var == {B, {787, 103.142}}` ]
-    [ [funcref boost::pfr::for_each_field for_each_field] ]
-][
-    [ [pfr_quick_examples_flat_for_each_idx] ]
-    [ ```0: char
-1: int
-2: double
-``` ]
-    [ [funcref boost::pfr::flat_for_each_field flat_for_each_field] ]
-][
-    [ [pfr_quick_examples_for_each_idx] ]
-    [ ```0: char
-1: quick_examples_ns::foo
-``` ]
-    [ [funcref boost::pfr::for_each_field for_each_field] ]
-][
-    [ [pfr_quick_examples_tuple_size] ]
-    [ `tuple_size: 2` ]
-    [ [classref boost::pfr::tuple_size tuple_size] ]
-][
-    [ [pfr_quick_examples_flat_tuple_size] ]
-    [ `flat_tuple_size: 3` ]
-    [ [classref boost::pfr::flat_tuple_size flat_tuple_size] ]
-][
-    [ [pfr_quick_examples_get_1] ]
-    [ `var == {A {1, 2.0}}` ]
-    [ [funcref boost::pfr::get get] ]
-][
-    [ [pfr_quick_examples_flat_get_1] ]
-    [ `var == {A, {1, 3.14159}}` ]
-    [ [funcref boost::pfr::flat_get flat_get] ]
-][
-    [ [pfr_quick_examples_get_2] ]
-    [ `var == {A, {777, 42.01}}` ]
-    [ [funcref boost::pfr::get get] ]
-][
-    [ [pfr_quick_examples_flat_get_2] ]
-    [ `var == {A, {777, 42.01}}` ]
-    [ [funcref boost::pfr::flat_get flat_get] ]
-][
-    [ [pfr_quick_examples_structure_to_tuple] ]
-    [ `var == {A, {777, 3.14159}}` ]
-    [ [funcref boost::pfr::structure_to_tuple structure_to_tuple] ]
-][
-    [ [pfr_quick_examples_flat_structure_to_tuple] ]
-    [ `var == {A, {777, 3.14159}}` ]
-    [ [funcref boost::pfr::flat_structure_to_tuple flat_structure_to_tuple] ]
-][
-    [ [pfr_quick_examples_structure_tie] ]
-    [ `var == {A, {1, 2.0}}` ]
-    [ [funcref boost::pfr::structure_tie structure_tie] ]
-][
-    [ [pfr_quick_examples_flat_structure_tie] ]
-    [ `var == {C, {777, 3.14159}}` ]
-    [ [funcref boost::pfr::flat_structure_tie flat_structure_tie] ]
-]]
+struct aggregate : empty { // not a SimpleAggregate
+    std::string name;
+    int age;
+    boost::uuids::uuid uuid;
+};
+```
+The library may work with aggregates that don't satisfy the requirements of `SimpleAggregate`, but the behavior tends to be non-portable.
 
-
-[endsect]
-
-
-[section Configuration Macro]
+[h2 Configuration Macro]
 
 By default Boost.PFR [*auto-detects your compiler abilities] and automatically defines the configuration macro into appropriate values. If you wish to override that behavior, just define:
 [table:linkmacro Macros
     [[Macro name] [Effect]]
-    [[*BOOST_PFR_USE_CPP17*] [Define to `1` if you wish to use structured bindings and other C++17 features for reflection. Define to `0` otherwize.]]
-    [[*BOOST_PFR_USE_LOOPHOLE*] [Define to `1` if you wish to exploit [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118 CWG 2118] for reflection. Define to `0` otherwize.]]
+    [[*BOOST_PFR_USE_CPP17*] [Define to `1` if you wish to override Boost.PFR choice and use C++17 structured bindings for reflection. Define to `0` to override Boost.PFR choice and disable C++17 structured bindings usage.]]
+    [[*BOOST_PFR_USE_LOOPHOLE*] [Define to `1` if you wish to override Boost.PFR choice and exploit [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118 CWG 2118] for reflection. Define to `0` to override Boost.PFR choice and disable CWG 2118 usage.]]
+    [[*BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE*] [Define to `0` if you are hit by the template instantiation depth issues with `std::make_integer_sequence` and wish to use Boost.PFR version of that metafunction. Define to `1` to override Boost.PFR detection logic. ]]
+    [[*BOOST_PFR_HAS_GUARANTEED_COPY_ELISION*] [Define to `0` if your compiler does not implement C++17 guaranteed copy elision properly and fails to reflect aggregates with non-movable fields. Define to `1` to override Boost.PFR detection logic. ]]
+    [[*BOOST_PFR_ENABLE_IMPLICIT_REFLECTION*] [Define to `0` if you are hit by lots of non-effective choices made by implicitly reflection. Define to `1` to override Boost.PFR detection logic. ]]
+    [[*BOOST_PFR_ENABLED*] [On platforms where Boost.PFR is not supported, the `boost/pfr/config.hpp` header defines the BOOST_PFR_ENABLED macro equal to 0. Defining this macro as 0 before including the header disables the Boost.PFR library. ]]
 ]
 
-Note that disabling [*Loophole] in C++14 significantly limitates the reflection abilities of the library. See next section for more info.
 
+[h2 Details on Limitations]
 
-[endsect]
+The Boost.PFRs reflection has some limitations that depend on a C++ Standard and compiler capabilities:
 
-
-[section Requirements and Limitations]
-
-[note Boost.PFR does not depend on any Boost library. You may use it's headers even without Boost. ]
-
-* Boost.PFR *requires C++14 compatible compiler* (GCC-5.0+, Clang, ...)
 * Static variables are ignored
-* T must be aggregate initializable
+* T must be aggregate initializable without base classes
+* if T contains C arrays then the result of reflection may differ depending on the C++ version and library configuration
+* Additional limitations if [*BOOST_PFR_USE_CPP17 == 0]:
+    * Non of the member fields should have a template constructor from one parameter.
+    * Additional limitations if [*BOOST_PFR_USE_LOOPHOLE == 0]:
+        * T must be constexpr aggregate initializable and all its fields must be constexpr default constructible
+        * [funcref boost::pfr::get], [funcref boost::pfr::structure_to_tuple], [funcref boost::pfr::structure_tie], [headerref boost/pfr/core.hpp boost::pfr::tuple_element] require T to be a POD type with built-in types only.
 
-[*Flat] functions limitations:
-
-* T must be POD and must not contain references nor bitfields
-* Enums will be returned as their underlying type
-
-C++14 [*precise] functions limitations with manually disabled [*Loophole](C++17 or not disabling Loophole fixes those):
-
-* T must be constexpr aggregate initializable and all it's fields must be constexpr default constructible
-* [funcref boost::pfr::get], [funcref boost::pfr::structure_to_tuple], [funcref boost::pfr::structure_tie], [headerref boost/pfr/precise/core.hpp boost::pfr::tuple_element] require T to be a flat POD type
-
-
-[*C++14] limitation (C++17 fixes those):
-
-* Non of the member fields has a template constructor from one parameter
 
 [endsect]
 
@@ -371,48 +509,42 @@ C++14 [*precise] functions limitations with manually disabled [*Loophole](C++17
 
 Short description:
 
-* Flat functions:
-    # at compile-time: use aggregate initialization to detect fields count in user-provided structure
-    # at compile-time: make a structure that is convertible to anything and remeber types it has been converted to during aggregate initialization of user-provided structure
-    # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure
-    # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step
-    # at run-time: get pointer to each field, knowing the structure address and each field offset
-    # at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure
-
-* Precise functions:
-    # at compile-time: use aggregate initialization to detect fields count in user-provided structure
-        * C++17:
-            # at compile-time: structured bindings are used to decompose a type `T` to known amount of fields
-        * C++14:
-            # Same approach as with [*flat] functions
-        * C++14 with disabled [*Loophole]:
-            # at compile-time: use flat reflection if it could precisely reflect the type. Otherwise:
-            # at compile-time: let `I` be is an index of current field, it equals 0
-            # at run-time: `T` is constructed and field `I` is aggregate initialized using a separate instance of structure that is convertible to anything [note Additional care is taken to make sure that all the information about `T` is available to the compiler and that operations on `T` have no side effects, so the compiler can optimize away the unnecessary temporary objects.]
-            # at compile-time: `I += 1`
-            # at compile-time: if `I` does not equal fields count goto step [~c.] from inside of the conversion operator of the structure that is convertible to anything
-            # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure
-            # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step
-            # at run-time: get pointer to each field, knowing the structure address and each field offset
-    # at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure
+# at compile-time: use aggregate initialization to detect fields count in user-provided structure
+    * [*BOOST_PFR_USE_CPP17 == 1]:
+        # at compile-time: structured bindings are used to decompose a type `T` to known amount of fields
+    * [*BOOST_PFR_USE_CPP17 == 0 && BOOST_PFR_USE_LOOPHOLE == 1]:
+        # at compile-time: use aggregate initialization to detect fields count in user-provided structure
+        # at compile-time: make a structure that is convertible to anything and remember types it has been converted to during aggregate initialization of user-provided structure
+        # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure
+        # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step
+        # at run-time: get pointer to each field, knowing the structure address and each field offset
+        # at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure
+    * [*BOOST_PFR_USE_CPP17 == 0 && BOOST_PFR_USE_LOOPHOLE == 0]:
+        # at compile-time: let `I` be is an index of current field, it equals 0
+        # at run-time: `T` is constructed and field `I` is aggregate initialized using a separate instance of structure that is convertible to anything [note Additional care is taken to make sure that all the information about `T` is available to the compiler and that operations on `T` have no side effects, so the compiler can optimize away the unnecessary temporary objects.]
+        # at compile-time: `I += 1`
+        # at compile-time: if `I` does not equal fields count goto step [~c.] from inside of the conversion operator of the structure that is convertible to anything
+        # at compile-time: using knowledge from previous steps create a tuple with exactly the same layout as in user-provided structure
+        # at compile-time: find offsets for each field in user-provided structure using the tuple from previous step
+        # at run-time: get pointer to each field, knowing the structure address and each field offset
+# at run-time: a tuple of references to fields is returned => all the tuple methods are available for the structure
 
 Long description of some basics: [@https://youtu.be/UlNUNxLtBI0 Antony Polukhin: Better C++14 reflections].
-Long description of some basics of C++14 with disabled [*Loophole]: [@https://youtu.be/abdeAew3gmQ Antony Polukhin: C++14 Reflections Without Macros, Markup nor External Tooling].
+Long description of some basics of C++14 with [link boost_pfr.limitations_and_configuration [*BOOST_PFR_USE_LOOPHOLE == 0]]: [@https://youtu.be/abdeAew3gmQ Antony Polukhin: C++14 Reflections Without Macros, Markup nor External Tooling].
+Description of the [*BOOST_PFR_USE_LOOPHOLE == 1] technique by its inventor Alexandr Poltavsky [@http://alexpolt.github.io/type-loophole.html in his blog].
 
 [endsect]
 
 [section Acknowledgements]
 
-Great thanks to Bruno Dutra for showing the technique to precisely reflect aggregate initializable type in C++14 [@https://github.com/apolukhin/magic_get/issues/5 Manual type registering/structured bindings might be unnecessary].
+Many thanks to Bruno Dutra for showing the technique to precisely reflect aggregate initializable type in C++14 [@https://github.com/boostorg/pfr/issues/5 Manual type registering/structured bindings might be unnecessary].
 
-Great thanks to Alexandr Poltavsky for initial implementation the [*Loophole] technique and for describing it [@http://alexpolt.github.io/type-loophole.html in his blog].
+Many thanks to Alexandr Poltavsky for initial implementation the [*BOOST_PFR_USE_LOOPHOLE == 1] technique and for describing it [@http://alexpolt.github.io/type-loophole.html in his blog].
 
-Great thanks to Chris Beck for implementing the detect-offsets-and-get-field-address functionality that avoids Undefined Behavior of reinterpret_casting layout compatible structures.
+Many thanks to Chris Beck for implementing the detect-offsets-and-get-field-address functionality that avoids Undefined Behavior of reinterpret_casting layout compatible structures.
+
+Many thanks to the Boost people who participated in the formal review, especially to Benedek Thaler, Steven Watanabe and Andrzej Krzemienski.
 
 [endsect]
 
-[section Reference]
-[xinclude autodoc_precise.xml]
-[xinclude autodoc_flat.xml]
-[xinclude autodoc_all.xml]
-[endsect]
+[xinclude autodoc_pfr.xml]

example/examples.cpp

@@ -1,129 +0,0 @@
-// Copyright 2016-2020 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-#include <cassert>
-
-
-//[pfr_intro
-#include <boost/pfr.hpp>
-
-struct nested_t { char c; };
-struct foo_t { int i; nested_t nested; };
-
-
-static_assert(std::is_same<
-    boost::pfr::flat_tuple_element_t<1, foo_t>, // Flat reflection.
-    char    // `char`, not `nested_t`!
->::value, "");
-
-
-// Requires C++17 or Loophole enabled:
-//<-
-#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE //->
-static_assert(std::is_same<
-    boost::pfr::tuple_element_t<1, foo_t>,      // Precise reflection.
-    nested_t
->::value, ""); //<-
-#endif //->
-//] [/pfr_intro]
-
-
-//[pfr_example_get
-/*`
-    The following example shows how to access structure fields by index using [funcref boost::pfr::get].
-
-    Let's define some structure:
-*/
-#include <boost/pfr/precise/core.hpp>
-
-struct foo {            // defining structure
-    int some_integer;
-    char c;
-};
-
-/*`
-    We can access fields of that structure by index:
-*/
-foo f {777, '!'};
-auto& r1 = boost::pfr::get<0>(f); // accessing field with index 0, returns reference to `foo::some_integer`
-auto& r2 = boost::pfr::get<1>(f); // accessing field with index 1, returns reference to `foo::c`
-//] [/pfr_example_get]
-
-//[pfr_example_tuple_size
-/*`
-    The following example shows how to count fields using [classref boost::pfr::tuple_size].
-*/
-#include <boost/pfr/precise/core.hpp>
-
-struct foo2 {            // defining structure
-    int some_integer;
-    char c;
-    short some_other_field;
-};
-
-
-static_assert(
-    boost::pfr::tuple_size<foo2>::value        // returns total count of fields in `foo2`
-    == 3, ""
-);
-
-static_assert(
-    boost::pfr::tuple_size<int[100]>::value    // works with arrays too!
-    == 100, ""
-);
-//] [/pfr_example_tuple_size]
-
-
-
-//[pfr_example_flattening
-/*`
-[warning All the functions and metafunctions in Boost.PFR that start with `flat_` represent template parameter type as flat structure without static members! ]
-
-Take a look at the `struct my_struct`:
-*/
-#include <boost/pfr/flat/core.hpp>
-
-struct my_struct_nested { short a1; int a2; };
-
-struct my_struct {
-    int a0;
-    static const int cvalue = 1000;
-    my_struct_nested nested;
-    short a3_a4[2];
-};
-
-/*` It will be flattened and represented as: */
-
-struct my_struct_flat {
-    int     a0;
-    short   a1;
-    int     a2;
-    short   a3;
-    short   a4;
-};
-//] [/pfr_example_flattening]
-
-void example_get() {
-//[pfr_example_flattening_2
-/*`
-It means, that:
-*/
-boost::pfr::flat_get<2>(my_struct{});   // ... will return `my_struct::my_struct_nested::a2` field.
-boost::pfr::flat_get<3>(my_struct{});   // ... will return `my_struct::a3_a4[0]` field.
-
-/*` Exactly the same story with arrays: */
-
-int i[2][2] = {{10, 11}, {12, 13} };
-const int& r = boost::pfr::flat_get<1>(i);
-assert(r == 11);
-//] [/pfr_example_flattening_2]
-(void)r;
-}
-
-
-int main() {
-    example_get();
-}

example/get.cpp

@@ -0,0 +1,42 @@
+// Copyright 2016-2023 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//[pfr_example_get
+/*`
+    The following example shows how to access structure fields by index using [funcref boost::pfr::get].
+
+    Let's define some structure:
+*/
+#include <boost/pfr/core.hpp>
+
+struct foo {            // defining structure
+    int some_integer;
+    char c;
+};
+
+/*`
+    We can access fields of that structure by index:
+*/
+foo f {777, '!'};
+auto& r1 = boost::pfr::get<0>(f); // accessing field with index 0, returns reference to `foo::some_integer`
+auto& r2 = boost::pfr::get<1>(f); // accessing field with index 1, returns reference to `foo::c`
+//] [/pfr_example_get]
+
+
+int main() {
+    if (r1 != 777) return 1;
+    if (r2 != '!') return 2;
+    
+    r1 = 42;
+    r2 = 'A';
+
+    if (r1 != 42) return 3;
+    if (r2 != 'A') return 4;
+    if (f.some_integer != 42) return 5;
+    if (f.c != 'A') return 6;
+
+    return 0;
+}

example/motivating_example0.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//[pfr_motivating_example
+#include <iostream>
+#include <string>
+
+#include "boost/pfr.hpp"
+
+struct some_person {
+    std::string name;
+    unsigned birth_year;
+};
+
+int main() {
+    some_person val{"Edgar Allan Poe", 1809};
+
+    std::cout << boost::pfr::get<0>(val)                // No macro!
+        << " was born in " << boost::pfr::get<1>(val);  // Works with any aggregate initializables!
+
+    std::cout << boost::pfr::io(val);                   // Outputs: {"Edgar Allan Poe", 1809}
+}
+//]

example/quick_examples.cpp

@@ -1,4 +1,4 @@
-// Copyright 2016-2020 Antony Polukhin
+// Copyright 2016-2023 Antony Polukhin
 
 // Distributed under the Boost Software License, Version 1.0.
 // (See the accompanying file LICENSE_1_0.txt
@@ -12,118 +12,66 @@
 #include <boost/pfr.hpp>
 #include <boost/type_index.hpp>
 
-
-//[pfr_quick_examples_structures
-struct foo {
-    int integer;
-    double real;
-    
-    void operator +=(int v) {
-        integer += v * 10;
-        real += v * 100;
-    }
-};
-
-struct bar {
-    char character;
-    foo f;
-};
-
-bar var{'A', {777, 3.141593}};
-//]
-    
-inline std::ostream& operator<<(std::ostream& os, const bar& b) {
-    return os << '{' << b.character << ", {" << b.f.integer << ", " << b.f.real << "}}";
-}
-
+// boost-no-inspect
 void test_examples() {
-  {
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_flat_functors_uset
-    // no `std::hash<bar>` or `bar::operator==(const bar&)` defined
-    std::unordered_set<
-        bar, boost::pfr::flat_hash<bar>,
-        boost::pfr::flat_equal_to<>> my_uset;
-    my_uset.insert(var);
-//]
-  }
-
-  {
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_flat_functors_set
-    // no `bar::operator<(const bar&)` defined
-    std::set<bar, boost::pfr::flat_less<>> my_set;
-    my_set.insert(var);
-//]
-  }
-
-  {
-//[pfr_quick_examples_flat_ops
-    using namespace boost::pfr::flat_ops; // Defines comparisons
-    assert((var < bar{'Z', {}} && var.f == foo{777, 3.141593}));
-//]
-    std::cout << "boost::pfr::flat_structure_tie(var) :\n" << var << '\n';
-  }
 
 #if BOOST_PFR_USE_CPP17
   {
 //[pfr_quick_examples_ops
-    struct test { std::string f1; std::string_view f2; };
-    using namespace boost::pfr::ops; // Defines comparisons
-    assert((test{"abc", ""} > test{"aaa", "zomg"}));
+    // Assert equality.
+    // Note that the equality operator for structure is not defined.
+
+    struct test {
+        std::string f1;
+        std::string_view f2;
+    };
+
+    assert(
+        boost::pfr::eq(test{"aaa", "zomg"}, test{"aaa", "zomg"})
+    );
 //]
   }
 #endif
 
   {
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_flat_for_each
-    // incrementing each field on 1:
-    boost::pfr::flat_for_each_field(var, [](auto& field) {
-        field += 1;
-    });
-//]
-    
-    std::cout << "flat_for_each_field outputs:\n" << var << '\n';
-  }
-    
-  {  
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_for_each    
-    // increments first field on 1, calls foo::operator+= for second field
+//[pfr_quick_examples_for_each
+    // Increment each field of the variable on 1 and
+    // output the content of the variable.
+
+    struct test {
+        int f1;
+        long f2;
+    };
+
+    test var{42, 43};
+
     boost::pfr::for_each_field(var, [](auto& field) {
         field += 1;
     });
-//]
-    
-    std::cout << "flat_for_each_field outputs:\n" << var << '\n';
-  }
 
-
-
-  
-  {
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_flat_for_each_idx  
-    boost::pfr::flat_for_each_field(var, [](auto& field, std::size_t idx) {
-        std::cout << idx << ": "
-            << boost::typeindex::type_id_runtime(field) << '\n';
-    });
+    // Outputs: {43, 44}
+    std::cout << boost::pfr::io(var);
 //]
   }
-    
-  {
-    bar var{'A', {777, 3.141593}};
 
-//[pfr_quick_examples_for_each_idx  
-    boost::pfr::for_each_field(var, [](auto& field, std::size_t idx) {
-        std::cout << idx << ": "
-            << boost::typeindex::type_id_runtime(field) << '\n';
+  {
+//[pfr_quick_examples_for_each_idx
+    // Iterate over fields of a variable and output index and
+    // type of a variable.
+
+    struct tag0{};
+    struct tag1{};
+    struct sample {
+        tag0 a;
+        tag1 b;
+    };
+
+    // Outputs:
+    //  0: tag0
+    //  1: tag1
+    boost::pfr::for_each_field(sample{}, [](const auto& field, std::size_t idx) {
+        std::cout << '\n' << idx << ": "
+            << boost::typeindex::type_id_runtime(field);
     });
 //]
   }
@@ -131,96 +79,111 @@ void test_examples() {
 
   {
 //[pfr_quick_examples_tuple_size
-    std::cout << "tuple_size: "
-        << boost::pfr::tuple_size<bar>::value << '\n';
+    // Getting fields count of some structure
+
+    struct some { int a,b,c,d,e; };
+
+    std::cout << "Fields count in structure: "
+        << boost::pfr::tuple_size<some>::value  // Outputs: 5
+        << '\n';
 //]
   }
-    
-  {    
-//[pfr_quick_examples_flat_tuple_size
-    std::cout << "flat_tuple_size: "
-        << boost::pfr::flat_tuple_size<bar>::value << '\n';
+
+  {
+//[pfr_quick_examples_get
+    // Get field by index/type and assign new value to that field
+
+    struct sample {
+        char c;
+        float f;
+    };
+
+    sample var{};
+    boost::pfr::get<1>(var) = 42.01f;
+    boost::pfr::get<char>(var) = 'A';
+
+    std::cout << var.c << var.f; // Outputs: A 42.01
 //]
   }
 
 #if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
   {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_get_1
-    boost::pfr::get<1>(var) = foo{1, 2}; // C++17 is required
-//]
-    std::cout << "boost::pfr::get<1>(var) outputs:\n" << var << '\n';
-  }
-#endif
-
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_flat_get_1
-    boost::pfr::flat_get<1>(var) = 1;
-//]
-    std::cout << "boost::pfr::flat_get<1>(var) outputs:\n" << var << '\n';
-  }
-  
-  
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_get_2
-    boost::pfr::get<1>(var.f) = 42.01;
-//]
-    std::cout << "boost::pfr::get<1>(var.f) outputs:\n" << var << '\n';
-  }
-
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_flat_get_2
-    boost::pfr::flat_get<1>(var.f) = 42.01;
-//]
-    std::cout << "boost::pfr::flat_get<1>(var.f) outputs:\n" << var << '\n';
-  }
-
-#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
-  {
-    bar var{'A', {777, 3.141593}};
 //[pfr_quick_examples_structure_to_tuple
-    // C++17 is required
+    // Getting a std::tuple of values from structures fields
+
+    struct foo { int a, b; };
+    struct other {
+        char c;
+        foo nested;
+    };
+
+    other var{'A', {3, 4}};
     std::tuple<char, foo> t = boost::pfr::structure_to_tuple(var);
-    std::get<1>(t) = foo{1, 2};
+    assert(std::get<0>(t) == 'A');
+    assert(
+        boost::pfr::eq(std::get<1>(t), foo{3, 4})
+    );
 //]
-    std::cout << "boost::pfr::structure_to_tuple(var) :\n" << var << '\n';
   }
 #endif
 
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_flat_structure_to_tuple
-    std::tuple<char, int, double> t = boost::pfr::flat_structure_to_tuple(var);
-    std::get<0>(t) = 'C';
-//]
-    std::cout << "boost::pfr::flat_structure_to_tuple(var) :\n" << var << '\n';
-  }
-
 #if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
   {
-    bar var{'A', {777, 3.141593}};
 //[pfr_quick_examples_structure_tie
-    // C++17 is required
+    // Getting a std::tuple of references to structure fields
+
+    struct foo { int a, b; };
+    struct other {
+        char c;
+        foo f;
+    };
+
+    other var{'A', {14, 15}};
     std::tuple<char&, foo&> t = boost::pfr::structure_tie(var);
     std::get<1>(t) = foo{1, 2};
+
+    std::cout << boost::pfr::io(var.f); // Outputs: {1, 2}
 //]
-    std::cout << "boost::pfr::structure_tie(var) :\n" << var << '\n';
   }
 #endif
 
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_flat_structure_tie
-    std::tuple<char&, int&, double&> t = boost::pfr::flat_structure_tie(var);
-    std::get<0>(t) = 'C';
-//]
-    std::cout << "boost::pfr::flat_structure_tie(var) :\n" << var << '\n';
-  }
-} // void test_examples() {
+} // void test_examples()
 
+//[pfr_quick_examples_functions_for
+// Define all the comparison and IO operators for my_structure type along
+// with hash_value function.
+
+#include <boost/pfr/functions_for.hpp>
+
+namespace my_namespace {
+    struct my_structure {
+        int a,b,c,d,e,f,g;
+        // ...
+    };
+    BOOST_PFR_FUNCTIONS_FOR(my_structure)
+}
+//]
+
+//[pfr_quick_examples_eq_fields
+// Define only the equality and inequality operators for my_eq_ne_structure.
+
+#include <boost/pfr/functions_for.hpp>
+
+namespace my_namespace {
+    struct my_eq_ne_structure {
+        float a,b,c,d,e,f,g;
+        // ...
+    };
+
+    inline bool operator==(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
+        return boost::pfr::eq_fields(x, y);
+    }
+
+    inline bool operator!=(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
+        return boost::pfr::ne_fields(x, y);
+    }
+}
+//]
 
 int main() {
     test_examples();

example/sample_printing.cpp

@@ -0,0 +1,95 @@
+// Copyright 2016-2023 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//[pfr_sample_printing
+/*`
+    The following example shows how to write your own io-manipulator for printing:
+*/
+#include <boost/pfr/ops.hpp>
+#include <ostream>
+
+namespace my_ns {
+
+/// Usage:
+///     struct foo {std::uint8_t a, b;};
+///     ...
+///     std::cout << my_ns::my_io(foo{42, 22});
+///
+/// Output: 42, 22
+template <class T>
+auto my_io(const T& value);
+
+namespace detail {
+    // Helpers to print individual values
+    template <class T>
+    void print_each(std::ostream& out, const T& v) { out << v; }
+    void print_each(std::ostream& out, std::uint8_t v) { out << static_cast<unsigned>(v); }
+    void print_each(std::ostream& out, std::int8_t v) { out << static_cast<int>(v); }
+
+    // Structure to keep a reference to value, that will be ostreamed lower
+    template <class T>
+    struct io_reference {
+        const T& value;
+    };
+
+    // Output each field of io_reference::value
+    template <class T>
+    std::ostream& operator<<(std::ostream& out, io_reference<T>&& x) {
+        const char* sep = "";
+
+        boost::pfr::for_each_field(x.value, [&](const auto& v) {
+            out << std::exchange(sep, ", ");
+            detail::print_each(out, v);
+        });
+        return out;
+    }
+}
+
+// Definition:
+template <class T>
+auto my_io(const T& value) {
+    return detail::io_reference<T>{value};
+}
+
+} // namespace my_ns
+//] [/pfr_sample_printing]
+
+
+#include <iostream>
+#include <sstream>
+
+int main() {
+    struct foo {std::uint8_t a, b;};
+
+    std::ostringstream oss;
+    oss << my_ns::my_io(foo{42, 22});
+
+    if (oss.str() != "42, 22") {
+        return 1;
+    }
+
+    struct two_big_strings {
+        std::string first;
+        std::string second;
+    };
+
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    const char* huge_string = "Some huge string that should not fit into std::string SSO."
+        "And by 'huge' I mean really HUGE string with multiple statements and a lot of periods........."
+    ;
+
+    oss.str({});
+    oss << my_ns::my_io(two_big_strings{
+        huge_string, huge_string
+    });
+
+    if (oss.str() != huge_string + std::string(", ") + huge_string) {
+        return 2;
+    }
+#endif
+
+    return 0;
+}

include/boost/pfr.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,10 +7,18 @@
 #define BOOST_PFR_HPP
 
 /// \file boost/pfr.hpp
-/// Includes all the Boost.PFR headers, except \xmlonly<link linkend='header.boost.pfr.flat.global_ops_hpp'>boost/pfr/flat/global_ops.hpp</link>\endxmlonly and \xmlonly<link linkend='header.boost.pfr.precise.global_ops_hpp'>boost/pfr/precise/global_ops.hpp</link>\endxmlonly
+/// Includes all the Boost.PFR headers
 
-#include <boost/pfr/precise.hpp>
-#include <boost/pfr/flat.hpp>
+#include <boost/pfr/config.hpp>
+#include <boost/pfr/core.hpp>
+#include <boost/pfr/functions_for.hpp>
+#include <boost/pfr/functors.hpp>
+#include <boost/pfr/io.hpp>
+#include <boost/pfr/io_fields.hpp>
+#include <boost/pfr/ops.hpp>
+#include <boost/pfr/ops_fields.hpp>
+#include <boost/pfr/tuple_size.hpp>
+#include <boost/pfr/traits_fwd.hpp>
+#include <boost/pfr/traits.hpp>
 
 #endif // BOOST_PFR_HPP
-

include/boost/pfr/config.hpp

@@ -0,0 +1,121 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_CONFIG_HPP
+#define BOOST_PFR_CONFIG_HPP
+#pragma once
+
+#if __cplusplus >= 201402L || (defined(_MSC_VER) && defined(_MSVC_LANG) && _MSC_VER > 1900)
+#include <type_traits> // to get non standard platform macro definitions (__GLIBCXX__ for example)
+#endif
+
+/// \file boost/pfr/config.hpp
+/// Contains all the macros that describe Boost.PFR configuration, like BOOST_PFR_ENABLED
+///
+/// \note This header file doesn't require C++14 Standard and supports all C++ compilers, even pre C++14 compilers (C++11, C++03...).
+
+// Reminder:
+//  * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????)
+//  * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017)
+//  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+//  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+
+#ifdef BOOST_PFR_NOT_SUPPORTED
+#   error Please, do not set BOOST_PFR_NOT_SUPPORTED value manually, use '-DBOOST_PFR_ENABLED=0' instead of it
+#endif
+
+#if defined(_MSC_VER)
+#   if !defined(_MSVC_LANG) || _MSC_VER <= 1900
+#       define BOOST_PFR_NOT_SUPPORTED 1
+#   endif
+#elif __cplusplus < 201402L
+#   define BOOST_PFR_NOT_SUPPORTED 1
+#endif
+
+#ifndef BOOST_PFR_USE_LOOPHOLE
+#   if defined(_MSC_VER)
+#       if _MSC_VER >= 1927
+#           define BOOST_PFR_USE_LOOPHOLE 1
+#       else
+#           define BOOST_PFR_USE_LOOPHOLE 0
+#       endif
+#   elif defined(__clang_major__) && __clang_major__ >= 8
+#       define BOOST_PFR_USE_LOOPHOLE 0
+#   else
+#       define BOOST_PFR_USE_LOOPHOLE 1
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_CPP17
+#   ifdef __cpp_structured_bindings
+#       define BOOST_PFR_USE_CPP17 1
+#   elif defined(_MSVC_LANG)
+#       if _MSVC_LANG >= 201703L
+#           define BOOST_PFR_USE_CPP17 1
+#       else
+#           define BOOST_PFR_USE_CPP17 0
+#       endif
+#   else
+#       define BOOST_PFR_USE_CPP17 0
+#   endif
+#endif
+
+#if (!BOOST_PFR_USE_CPP17 && !BOOST_PFR_USE_LOOPHOLE)
+#   if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works
+#      define BOOST_PFR_NOT_SUPPORTED 1
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
+// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
+#   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+#   elif defined(_MSC_VER)
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+//# elif other known working lib
+#   else
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
+#   if  defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928)
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 1
+#   else
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+#   if  defined(__cpp_lib_is_aggregate)
+#       define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 1
+#   else
+// There is no way to detect potential ability to be reflectable without std::is_aggregare
+#       define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 0
+#   endif
+#endif
+
+#if defined(__has_cpp_attribute)
+#   if __has_cpp_attribute(maybe_unused)
+#       define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]]
+#   endif
+#endif
+
+#ifndef BOOST_PFR_MAYBE_UNUSED
+#   define BOOST_PFR_MAYBE_UNUSED
+#endif
+
+#ifndef BOOST_PFR_ENABLED
+#   ifdef BOOST_PFR_NOT_SUPPORTED
+#       define BOOST_PFR_ENABLED 0
+#   else
+#       define BOOST_PFR_ENABLED 1
+#   endif
+#endif
+
+#undef BOOST_PFR_NOT_SUPPORTED
+
+#endif // BOOST_PFR_CONFIG_HPP

include/boost/pfr/core.hpp

@@ -0,0 +1,265 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_CORE_HPP
+#define BOOST_PFR_CORE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/stdtuple.hpp>
+#include <boost/pfr/detail/for_each_field_impl.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/tie_from_structure_tuple.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/tuple_size.hpp>
+
+/// \file boost/pfr/core.hpp
+/// Contains all the basic tuple-like interfaces \forcedlink{get}, \forcedlink{tuple_size}, \forcedlink{tuple_element_t}, and others.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+/// \brief Returns reference or const reference to a field with index `I` in \aggregate `val`.
+/// Overload taking the type `U` returns reference or const reference to a field
+/// with provided type `U` in \aggregate `val` if there's only one field of such type in `val`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     my_struct s {10, 11};
+///
+///     assert(boost::pfr::get<0>(s) == 10);
+///     boost::pfr::get<1>(s) = 0;
+///
+///     assert(boost::pfr::get<int>(s) == 10);
+///     boost::pfr::get<short>(s) = 11;
+/// \endcode
+template <std::size_t I, class T>
+constexpr decltype(auto) get(const T& val) noexcept {
+    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
+}
+
+/// \overload get
+template <std::size_t I, class T>
+constexpr decltype(auto) get(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload get
+template <std::size_t I, class T>
+constexpr auto get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload get
+template <std::size_t I, class T>
+constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
+    return std::move(detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) ));
+}
+
+
+/// \overload get
+template <class U, class T>
+constexpr const U& get(const T& val) noexcept {
+    return detail::sequence_tuple::get_by_type_impl<const U&>( detail::tie_as_tuple(val) );
+}
+
+
+/// \overload get
+template <class U, class T>
+constexpr U& get(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload get
+template <class U, class T>
+constexpr U& get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload get
+template <class U, class T>
+constexpr U&& get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
+    return std::move(detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) ));
+}
+
+
+/// \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T.
+///
+/// \b Example:
+/// \code
+///     std::vector< boost::pfr::tuple_element<0, my_structure>::type > v;
+/// \endcode
+template <std::size_t I, class T>
+using tuple_element = detail::sequence_tuple::tuple_element<I, decltype( ::boost::pfr::detail::tie_as_tuple(std::declval<T&>()) ) >;
+
+
+/// \brief Type of a field with index `I` in \aggregate `T`.
+///
+/// \b Example:
+/// \code
+///     std::vector< boost::pfr::tuple_element_t<0, my_structure> > v;
+/// \endcode
+template <std::size_t I, class T>
+using tuple_element_t = typename tuple_element<I, T>::type;
+
+
+/// \brief Creates a `std::tuple` from fields of an \aggregate `val`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     my_struct s {10, 11};
+///     std::tuple<int, short> t = boost::pfr::structure_to_tuple(s);
+///     assert(get<0>(t) == 10);
+/// \endcode
+template <class T>
+constexpr auto structure_to_tuple(const T& val) noexcept {
+    return detail::make_stdtuple_from_tietuple(
+        detail::tie_as_tuple(val),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+
+/// \brief std::tie` like function that ties fields of a structure.
+///
+/// \returns a `std::tuple` with lvalue and const lvalue references to fields of an \aggregate `val`.
+///
+/// \b Example:
+/// \code
+///     void foo(const int&, const short&);
+///     struct my_struct { int i, short s; };
+///
+///     const my_struct const_s{1, 2};
+///     std::apply(foo, boost::pfr::structure_tie(const_s));
+///
+///     my_struct s;
+///     boost::pfr::structure_tie(s) = std::tuple<int, short>{10, 11};
+///     assert(s.s == 11);
+/// \endcode
+template <class T>
+constexpr auto structure_tie(const T& val) noexcept {
+    return detail::make_conststdtiedtuple_from_tietuple(
+        detail::tie_as_tuple(const_cast<T&>(val)),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::make_stdtiedtuple_from_tietuple(
+        detail::tie_as_tuple(val),
+        detail::make_index_sequence< tuple_size_v<T> >()
+    );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload structure_tie
+template <class T>
+constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on rvalue references is forbidden");
+    return 0;
+}
+
+/// Calls `func` for each field of a `value`.
+///
+/// \param func must have one of the following signatures:
+///     * any_return_type func(U&& field)                // field of value is perfect forwarded to function
+///     * any_return_type func(U&& field, std::size_t i)
+///     * any_return_type func(U&& value, I i)           // Here I is an `std::integral_constant<size_t, field_index>`
+///
+/// \param value To each field of this variable will be the `func` applied.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     int sum = 0;
+///     boost::pfr::for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
+///     assert(sum == 42);
+/// \endcode
+template <class T, class F>
+void for_each_field(T&& value, F&& func) {
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [f = std::forward<F>(func)](auto&& t) mutable {
+            // MSVC related workaround. Its lambdas do not capture constexprs.
+            constexpr std::size_t fields_count_val_in_lambda
+                = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+
+            ::boost::pfr::detail::for_each_field_impl(
+                t,
+                std::forward<F>(f),
+                detail::make_index_sequence<fields_count_val_in_lambda>{},
+                std::is_rvalue_reference<T&&>{}
+            );
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+}
+
+/// \brief std::tie-like function that allows assigning to tied values from aggregates.
+///
+/// \returns an object with lvalue references to `args...`; on assignment of an \aggregate value to that
+/// object each field of an aggregate is assigned to the corresponding `args...` reference.
+///
+/// \b Example:
+/// \code
+///     auto f() {
+///       struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 };
+///       return res;
+///     }
+///     auto [p, s] = f();
+///     boost::pfr::tie_from_structure(p, s) = f();
+/// \endcode
+template <typename... Elements>
+constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Elements&... args) noexcept {
+    return detail::tie_from_structure_tuple<Elements...>(args...);
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_CORE_HPP

include/boost/pfr/detail/cast_to_layout_compatible.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/pfr/detail/config.hpp

@@ -1,4 +1,5 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2022 Denis Mikhailov
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,46 +8,19 @@
 #define BOOST_PFR_DETAIL_CONFIG_HPP
 #pragma once
 
-// Reminder:
-//  * MSVC++ 1?.? _MSC_VER >  1900 (Visual Studio 2017)
-//  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
-//  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+#include <boost/pfr/config.hpp>
 
-#if defined(_MSC_VER)
-#   if _MSC_VER <= 1900
-#       error Boost.PFR library requires MSVC with c++17 support (Visual Studio 2017 or later).
-#   endif
-#elif __cplusplus < 201402L
-#   error Boost.PFR library requires at least C++14.
-#endif
+#if !BOOST_PFR_ENABLED
 
-#ifndef BOOST_PFR_USE_LOOPHOLE
-#   if !defined(__clang_major__) || __clang_major__ < 8
-#       define BOOST_PFR_USE_LOOPHOLE 1
-#   endif
-#endif
+#error Boost.PFR library is not supported in your environment.             \
+       Try one of the possible solutions:                                  \
+       1. try to take away an '-DBOOST_PFR_ENABLED=0', if it exists        \
+       2. enable C++14;                                                    \
+       3. enable C++17;                                                    \
+       4. update your compiler;                                            \
+       or disable this error by '-DBOOST_PFR_ENABLED=1' if you really know what are you doing.
 
-#ifndef BOOST_PFR_USE_CPP17
-#   ifdef __cpp_structured_bindings
-#       define BOOST_PFR_USE_CPP17 1
-#   elif defined(_MSC_VER)
-#       warning PFR library supports MSVC compiler only with /std:c++latest or /std:c++17 flag. Assuming that you`ve used it. Define `BOOST_PFR_USE_CPP17` to 1 to suppress this warning.
-#       define BOOST_PFR_USE_CPP17 1
-#   else
-#       define BOOST_PFR_USE_CPP17 0
-#   endif
-#endif
-
-#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
-// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
-#   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
-#   elif defined(_MSC_VER)
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
-//# elif other known working lib
-#   else
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
-#   endif
-#endif
+#endif // !BOOST_PFR_ENABLED
 
 #endif // BOOST_PFR_DETAIL_CONFIG_HPP
+

include/boost/pfr/detail/core.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_CORE_HPP
+#define BOOST_PFR_DETAIL_CORE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+// Each core provides `boost::pfr::detail::tie_as_tuple` and
+// `boost::pfr::detail::for_each_field_dispatcher` functions.
+//
+// The whole PFR library is build on top of those two functions.
+#if BOOST_PFR_USE_CPP17
+#   include <boost/pfr/detail/core17.hpp>
+#elif BOOST_PFR_USE_LOOPHOLE
+#   include <boost/pfr/detail/core14_loophole.hpp>
+#else
+#   include <boost/pfr/detail/core14_classic.hpp>
+#endif
+
+#endif // BOOST_PFR_DETAIL_CORE_HPP

include/boost/pfr/detail/core14.hpp

@@ -1,18 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_DETAIL_CORE14_HPP
-#define BOOST_PFR_DETAIL_CORE14_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#if BOOST_PFR_USE_LOOPHOLE
-#   include <boost/pfr/detail/core14_loophole.hpp>
-#else
-#   include <boost/pfr/detail/core14_classic.hpp>
-#endif
-
-#endif // BOOST_PFR_DETAIL_CORE14_HPP

include/boost/pfr/detail/core14_classic.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,6 +18,7 @@
 #include <boost/pfr/detail/make_flat_tuple_of_references.hpp>
 #include <boost/pfr/detail/make_integer_sequence.hpp>
 #include <boost/pfr/detail/size_array.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
 #include <boost/pfr/detail/rvalue_t.hpp>
 
 #ifdef __clang__
@@ -32,10 +33,7 @@ namespace boost { namespace pfr { namespace detail {
 
 ///////////////////// General utility stuff
 
-template <std::size_t Index>
-using size_t_ = std::integral_constant<std::size_t, Index >;
-
-template <class T> struct identity{
+template <class T> struct identity {
     typedef T type;
 };
 
@@ -55,7 +53,7 @@ namespace typeid_conversions {
 #ifdef _MSC_VER
 #   pragma warning( push )
     // '<<': check operator precedence for possible error; use parentheses to clarify precedence
-#   pragma warning( disable : 4554 ) 
+#   pragma warning( disable : 4554 )
 #endif
 
 constexpr std::size_t native_types_mask = 31;
@@ -120,16 +118,16 @@ template <class Type> constexpr std::size_t type_to_id(identity<const Type*>) no
 template <class Type> constexpr std::size_t type_to_id(identity<const volatile Type*>) noexcept;
 template <class Type> constexpr std::size_t type_to_id(identity<volatile Type*>) noexcept;
 template <class Type> constexpr std::size_t type_to_id(identity<Type&>) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>* = 0) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>* = 0) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>* = 0) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>* = nullptr) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>* = nullptr) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>* = nullptr) noexcept;
 template <class Type> constexpr size_array<sizeof(Type) * 3> type_to_id(identity<Type>, std::enable_if_t<!std::is_enum<Type>::value && !std::is_empty<Type>::value && !std::is_union<Type>::value>* = 0) noexcept;
 
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type> = nullptr) noexcept;
 
 
 ///////////////////// Definitions of type_to_id and id_to_type for fundamental types
@@ -508,7 +506,10 @@ template <class T>
 constexpr auto internal_tuple_with_same_alignment() noexcept {
     typedef typename std::remove_cv<T>::type type;
 
-    static_assert(std::is_pod<type>::value, "====================> Boost.PFR: Type can not be used is flat_ functions, because it's not POD");
+    static_assert(
+        std::is_trivial<type>::value && std::is_standard_layout<type>::value,
+        "====================> Boost.PFR: Type can not be reflected without Loophole or C++17, because it's not POD"
+    );
     static_assert(!std::is_reference<type>::value, "====================> Boost.PFR: Not applyable");
     constexpr auto res = detail::as_flat_tuple_impl<type>(
         detail::make_index_sequence< decltype(detail::flat_array_of_type_ids<type>())::size() >()
@@ -527,7 +528,7 @@ struct ubiq_is_flat_refelectable {
 
     template <class Type>
     constexpr operator Type() const noexcept {
-        is_flat_refelectable = std::is_fundamental<Type>::value;
+        is_flat_refelectable = std::is_fundamental<std::remove_pointer_t<Type>>::value;
         return {};
     }
 };
@@ -548,6 +549,11 @@ constexpr bool is_flat_refelectable(std::index_sequence<I...>) noexcept {
     return true;
 }
 
+template<class T>
+constexpr bool is_flat_refelectable(std::index_sequence<>) noexcept {
+    return true; ///< all empty structs always flat refelectable
+}
+
 template <class T>
 auto tie_as_flat_tuple(T& lvalue) noexcept {
     static_assert(
@@ -561,8 +567,6 @@ auto tie_as_flat_tuple(T& lvalue) noexcept {
     return boost::pfr::detail::make_flat_tuple_of_references(lvalue, getter, size_t_<0>{}, size_t_<tuple_type::size_v>{});
 }
 
-#if !BOOST_PFR_USE_CPP17
-
 template <class T>
 auto tie_as_tuple(T& val) noexcept {
     static_assert(
@@ -571,13 +575,11 @@ auto tie_as_tuple(T& val) noexcept {
     );
     static_assert(
         boost::pfr::detail::is_flat_refelectable<T>( detail::make_index_sequence<boost::pfr::detail::fields_count<T>()>{} ),
-        "====================> Boost.PFR: Not possible in C++14 to represent that type without loosing information. Use boost::pfr::flat_ version, or change type definition, or enable C++17"
+        "====================> Boost.PFR: Not possible in C++14 to represent that type without loosing information. Change type definition or enable C++17"
     );
     return boost::pfr::detail::tie_as_flat_tuple(val);
 }
 
-#endif // #if !BOOST_PFR_USE_CPP17
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////// Structure that can be converted to copy of anything
@@ -596,16 +598,21 @@ struct ubiq_constructor_constexpr_copy {
 
 /////////////////////
 
-#if !BOOST_PFR_USE_CPP17
-
 template <class T, std::size_t... I>
-struct is_constexpr_aggregate_initializable { // TODO: try to fix it
-    template <T = T{ ubiq_constructor_constexpr_copy{I}... } >
+struct is_constexpr_aggregate_initializable {
+    template<class T2, std::size_t... I2>
+    static constexpr void* constexpr_aggregate_initializer() noexcept {
+        T2 tmp{ ubiq_constructor_constexpr_copy{I2}... };
+        (void)tmp;
+        return nullptr;
+    }
+
+    template <void* = constexpr_aggregate_initializer<T, I...>() >
     static std::true_type test(long) noexcept;
 
     static std::false_type test(...) noexcept;
 
-    static constexpr decltype( test(0) ) value{};
+    static constexpr bool value = decltype(test(0)){};
 };
 
 
@@ -676,16 +683,7 @@ void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
         !std::is_union<T>::value,
         "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
     );
-
-    /// Compile time error at this point means that you have called `for_each_field` or some other non-flat function or operator for a
-    /// type that is not constexpr aggregate initializable.
-    ///
-    /// Make sure that all the fields of your type have constexpr default construtors and trivial destructors.
-    /// Or compile in C++17 mode.
-    constexpr T tmp{ ubiq_constructor_constexpr_copy{I}... };
-    (void)tmp;
-
-    //static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");
+    static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");
 
     constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable<T>( std::index_sequence<I...>{} );
     detail::for_each_field_dispatcher_1(
@@ -696,8 +694,6 @@ void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
     );
 }
 
-#endif // #if !BOOST_PFR_USE_CPP17
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 

include/boost/pfr/detail/core14_loophole.hpp

@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin.
-// Copyright (c) 2019-2020 Antony Polukhin.
+// Copyright (c) 2019-2023 Antony Polukhin.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -8,7 +8,7 @@
 // The Great Type Loophole (C++14)
 // Initial implementation by Alexandr Poltavsky, http://alexpolt.github.io
 //
-// Description: 
+// Description:
 //  The Great Type Loophole is a technique that allows to exchange type information with template
 //  instantiations. Basically you can assign and read type information during compile time.
 //  Here it is used to detect data members of a data type. I described it for the first time in
@@ -20,6 +20,7 @@
 
 #ifndef BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
 #define BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
+#pragma once
 
 #include <boost/pfr/detail/config.hpp>
 
@@ -33,6 +34,7 @@
 #include <boost/pfr/detail/make_integer_sequence.hpp>
 #include <boost/pfr/detail/sequence_tuple.hpp>
 #include <boost/pfr/detail/rvalue_t.hpp>
+#include <boost/pfr/detail/unsafe_declval.hpp>
 
 
 #ifdef __clang__
@@ -59,12 +61,6 @@ struct tag {
     friend auto loophole(tag<T,N>);
 };
 
-// For returning non default constructible types. Never used at runtime! GCC's std::declval may not be used in potentionally evaluated contexts, so it does not work here.
-template <class T> constexpr T& unsafe_declval_like() noexcept {
-    T* ptr = nullptr;
-    return *ptr;
-}
-
 // The definitions of friend functions.
 template <class T, class U, std::size_t N, bool B>
 struct fn_def_lref {
@@ -75,13 +71,13 @@ struct fn_def_lref {
         // To workaround the issue, we check that the type U is movable, and move it in that case.
         using no_extents_t = std::remove_all_extents_t<U>;
         return static_cast< std::conditional_t<std::is_move_constructible<no_extents_t>::value, no_extents_t&&, no_extents_t&> >(
-            boost::pfr::detail::unsafe_declval_like<no_extents_t>()
+            boost::pfr::detail::unsafe_declval<no_extents_t&>()
         );
     }
 };
 template <class T, class U, std::size_t N, bool B>
 struct fn_def_rref {
-    friend auto loophole(tag<T,N>) { return std::move(boost::pfr::detail::unsafe_declval_like< std::remove_all_extents_t<U> >()); }
+    friend auto loophole(tag<T,N>) { return std::move(boost::pfr::detail::unsafe_declval< std::remove_all_extents_t<U>& >()); }
 };
 
 
@@ -103,7 +99,7 @@ struct loophole_ubiq_lref {
     template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
 
     template<class U, std::size_t = sizeof(fn_def_lref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
-    constexpr operator U&() const noexcept; // `const` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
+    constexpr operator U&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
 };
 
 template <class T, std::size_t N>
@@ -112,7 +108,7 @@ struct loophole_ubiq_rref {
     template<class U, std::size_t M, std::size_t = sizeof(loophole(tag<T,M>{})) > static char ins(int);
 
     template<class U, std::size_t = sizeof(fn_def_rref<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
-    constexpr operator U&&() const noexcept; // `const` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
+    constexpr operator U&&() const&& noexcept; // `const&&` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
 };
 
 
@@ -169,81 +165,6 @@ auto tie_as_tuple_loophole_impl(T& lvalue) noexcept {
     );
 }
 
-// Forward declarations:
-template <class T> auto tie_as_tuple_recursively(rvalue_t<T> val) noexcept;
-
-template <class T>
-auto tie_or_value(T& val, std::enable_if_t<std::is_class< std::remove_reference_t<T> >::value>* = 0) noexcept {
-    return boost::pfr::detail::tie_as_tuple_recursively(
-        boost::pfr::detail::tie_as_tuple_loophole_impl(val)
-    );
-}
-
-template <class T>
-decltype(auto) tie_or_value(T& val, std::enable_if_t<std::is_enum<std::remove_reference_t<T>>::value>* = 0) noexcept {
-    // This is compatible with the pre-loophole implementation, and tests, but IIUC it violates strict aliasing unfortunately
-    return detail::cast_to_layout_compatible<
-        std::underlying_type_t<std::remove_reference_t<T> >
-    >(val);
-#if 0
-    // This "works", in that it's usable and it doesn't violate strict aliasing.
-    // But it means we break compatibility and don't convert enum to underlying type.
-    return val;
-#endif
-}
-
-template <class T>
-auto tie_or_value(T& val, std::enable_if_t<std::is_union< std::remove_reference_t<T> >::value>* = 0) noexcept {
-    static_assert(
-        sizeof(T) && false,
-        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
-    );
-    return 0;
-}
-
-template <class T>
-decltype(auto) tie_or_value(T& val, std::enable_if_t<!std::is_class< std::remove_reference_t<T> >::value && !std::is_enum< std::remove_reference_t<T> >::value && !std::is_union< std::remove_reference_t<T> >::value>* = 0) noexcept {
-    return val;
-}
-
-template <class T, std::size_t... I>
-auto tie_as_tuple_recursively_impl(T& tup, std::index_sequence<I...> ) noexcept
-    ->  sequence_tuple::tuple<
-            decltype(boost::pfr::detail::tie_or_value(
-                sequence_tuple::get<I>(tup)
-            ))...
-        >
-{
-    return {
-        boost::pfr::detail::tie_or_value(
-            sequence_tuple::get<I>(tup)
-        )...
-    };
-}
-
-template <class T>
-auto tie_as_tuple_recursively(rvalue_t<T> tup) noexcept {
-    using indexes = detail::make_index_sequence<T::size_v>;
-    return boost::pfr::detail::tie_as_tuple_recursively_impl(tup, indexes{});
-}
-
-template <class T>
-auto tie_as_flat_tuple(T& t) {
-    static_assert(
-        !std::is_union<T>::value,
-        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
-    );
-    auto rec_tuples = boost::pfr::detail::tie_as_tuple_recursively(
-        boost::pfr::detail::tie_as_tuple_loophole_impl(t)
-    );
-
-    return boost::pfr::detail::make_flat_tuple_of_references(
-        rec_tuples, sequence_tuple_getter{}, size_t_<0>{}, size_t_<decltype(rec_tuples)::size_v>{}
-    );
-}
-
-
-#if !BOOST_PFR_USE_CPP17
 template <class T>
 auto tie_as_tuple(T& val) noexcept {
     static_assert(
@@ -266,8 +187,6 @@ void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
     );
 }
 
-#endif // #if !BOOST_PFR_USE_CPP17
-
 }}} // namespace boost::pfr::detail
 
 

include/boost/pfr/detail/core17.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -6,8 +6,10 @@
 
 #ifndef BOOST_PFR_DETAIL_CORE17_HPP
 #define BOOST_PFR_DETAIL_CORE17_HPP
+#pragma once
 
 #include <boost/pfr/detail/core17_generated.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
 #include <boost/pfr/detail/for_each_field_impl.hpp>
 #include <boost/pfr/detail/rvalue_t.hpp>
 
@@ -21,7 +23,7 @@ struct do_not_define_std_tuple_size_for_me {
 template <class T>
 constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
     T val{};
-    const auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
+    auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
 
     /****************************************************************************
     *
@@ -44,6 +46,16 @@ static_assert(
 );
 #endif // #ifndef _MSC_VER
 
+template <class T>
+constexpr auto tie_as_tuple(T& val) noexcept {
+  static_assert(
+    !std::is_union<T>::value,
+    "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+  );
+  typedef size_t_<boost::pfr::detail::fields_count<T>()> fields_count_tag;
+  return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{});
+}
+
 template <class T, class F, std::size_t... I>
 void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
     static_assert(

include/boost/pfr/detail/detectors.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,49 +9,58 @@
 
 #include <boost/pfr/detail/config.hpp>
 
+#include <functional>
+#include <type_traits>
+
 namespace boost { namespace pfr { namespace detail {
 ///////////////////// `value` is true if Detector<Tleft, Tright> does not compile (SFINAE)
-	struct success{};
+    struct can_not_apply{};
+
     template <template <class, class> class Detector, class Tleft, class Tright>
     struct not_appliable {
         static constexpr bool value = std::is_same<
             Detector<Tleft, Tright>,
-            success
+            can_not_apply
         >::value;
     };
 
 ///////////////////// Detectors for different operators
     template <class S, class T> auto comp_eq_detector_msvc_helper(long) -> decltype(std::declval<S>() == std::declval<T>());
-    template <class S, class T> success comp_eq_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply comp_eq_detector_msvc_helper(int);
     template <class T1, class T2> using comp_eq_detector = decltype(comp_eq_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_ne_detector_msvc_helper(long) -> decltype(std::declval<S>() != std::declval<T>());
-    template <class S, class T> success comp_ne_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_ne_detector =  decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_ne_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ne_detector = decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_lt_detector_msvc_helper(long) -> decltype(std::declval<S>() < std::declval<T>());
-    template <class S, class T> success comp_lt_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_lt_detector =  decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_lt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_lt_detector = decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_le_detector_msvc_helper(long) -> decltype(std::declval<S>() <= std::declval<T>());
-    template <class S, class T> success comp_le_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_le_detector =  decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_le_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_le_detector = decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_gt_detector_msvc_helper(long) -> decltype(std::declval<S>() > std::declval<T>());
-    template <class S, class T> success comp_gt_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_gt_detector =   decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_gt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_gt_detector = decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_ge_detector_msvc_helper(long) -> decltype(std::declval<S>() >= std::declval<T>());
-    template <class S, class T> success comp_ge_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_ge_detector =   decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_ge_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ge_detector = decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
+
+
+    template <class S> auto hash_detector_msvc_helper(long) -> decltype(std::hash<S>{}(std::declval<S>()));
+    template <class S> can_not_apply hash_detector_msvc_helper(int);
+    template <class T1, class T2> using hash_detector = decltype(hash_detector_msvc_helper<T1,T2>(1L));
 
 
     template <class S, class T> auto ostreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() << std::declval<T>());
-    template <class S, class T> success ostreamable_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply ostreamable_detector_msvc_helper(int);
     template <class S, class T> using ostreamable_detector = decltype(ostreamable_detector_msvc_helper<S,T>(1L));
 
     template <class S, class T> auto istreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() >> std::declval<T>());
-    template <class S, class T> success istreamable_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply istreamable_detector_msvc_helper(int);
     template <class S, class T> using istreamable_detector = decltype(istreamable_detector_msvc_helper<S,T>(1L));
 
 }}} // namespace boost::pfr::detail

include/boost/pfr/detail/fields_count.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,6 +9,8 @@
 
 #include <boost/pfr/detail/config.hpp>
 #include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+#include <boost/pfr/detail/unsafe_declval.hpp>
 
 #include <climits>      // CHAR_BIT
 #include <type_traits>
@@ -24,36 +26,44 @@
 
 namespace boost { namespace pfr { namespace detail {
 
-///////////////////// General utility stuff
-template <std::size_t Index>
-using size_t_ = std::integral_constant<std::size_t, Index >;
-
 ///////////////////// Structure that can be converted to reference to anything
 struct ubiq_lref_constructor {
     std::size_t ignore;
-    template <class Type> /*constexpr*/ operator Type&() const noexcept; // Undefined, allows initialization of reference fields (T& and const T&)
+    template <class Type> constexpr operator Type&() const && noexcept {  // tweak for template_unconstrained.cpp like cases
+        return detail::unsafe_declval<Type&>();
+    }
+
+    template <class Type> constexpr operator Type&() const & noexcept {  // tweak for optional_chrono.cpp like cases
+        return detail::unsafe_declval<Type&>();
+    }
 };
 
 ///////////////////// Structure that can be converted to rvalue reference to anything
 struct ubiq_rref_constructor {
     std::size_t ignore;
-    template <class Type> /*constexpr*/ operator Type&&() const noexcept; // Undefined, allows initialization of rvalue reference fields and move-only types
+    template <class Type> /*constexpr*/ operator Type() const && noexcept {  // Allows initialization of rvalue reference fields and move-only types
+        return detail::unsafe_declval<Type>();
+    }
 };
 
-///////////////////// Structure that can be converted to reference to anything except reference to T
+
+#ifndef __cpp_lib_is_aggregate
+///////////////////// Hand-made is_aggregate_initializable_n<T> trait
+
+// Structure that can be converted to reference to anything except reference to T
 template <class T, bool IsCopyConstructible>
 struct ubiq_constructor_except {
+    std::size_t ignore;
     template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&> () const noexcept; // Undefined
 };
 
 template <class T>
 struct ubiq_constructor_except<T, false> {
+    std::size_t ignore;
     template <class Type> constexpr operator std::enable_if_t<!std::is_same<T, Type>::value, Type&&> () const noexcept; // Undefined
 };
 
 
-///////////////////// Hand-made is_aggregate_initializable_n<T> trait
-
 // `std::is_constructible<T, ubiq_constructor_except<T>>` consumes a lot of time, so we made a separate lazy trait for it.
 template <std::size_t N, class T> struct is_single_field_and_aggregate_initializable: std::false_type {};
 template <class T> struct is_single_field_and_aggregate_initializable<1, T>: std::integral_constant<
@@ -61,7 +71,8 @@ template <class T> struct is_single_field_and_aggregate_initializable<1, T>: std
 > {};
 
 // Hand-made is_aggregate<T> trait:
-// Aggregates could be constructed from `decltype(ubiq_?ref_constructor{I})...` but report that there's no constructor from `decltype(ubiq_?ref_constructor{I})...`
+// Before C++20 aggregates could be constructed from `decltype(ubiq_?ref_constructor{I})...` but type traits report that
+// there's no constructor from `decltype(ubiq_?ref_constructor{I})...`
 // Special case for N == 1: `std::is_constructible<T, ubiq_?ref_constructor>` returns true if N == 1 and T is copy/move constructible.
 template <class T, std::size_t N>
 struct is_aggregate_initializable_n {
@@ -80,6 +91,62 @@ struct is_aggregate_initializable_n {
     ;
 };
 
+#endif // #ifndef __cpp_lib_is_aggregate
+
+///////////////////// Detect aggregates with inheritance
+template <class Derived, class U>
+constexpr bool static_assert_non_inherited() noexcept {
+    static_assert(
+            !std::is_base_of<U, Derived>::value,
+            "====================> Boost.PFR: Boost.PFR: Inherited types are not supported."
+    );
+    return true;
+}
+
+template <class Derived>
+struct ubiq_lref_base_asserting {
+    template <class Type> constexpr operator Type&() const &&  // tweak for template_unconstrained.cpp like cases
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type&>();
+    }
+
+    template <class Type> constexpr operator Type&() const &  // tweak for optional_chrono.cpp like cases
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type&>();
+    }
+};
+
+template <class Derived>
+struct ubiq_rref_base_asserting {
+    template <class Type> /*constexpr*/ operator Type() const &&  // Allows initialization of rvalue reference fields and move-only types
+        noexcept(detail::static_assert_non_inherited<Derived, Type>())  // force the computation of assert function
+    {
+        return detail::unsafe_declval<Type>();
+    }
+};
+
+template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
+constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_lref_base_asserting<T>{}, ubiq_lref_constructor{I}... })>::type
+{
+    return nullptr;
+}
+
+template <class T, std::size_t I0, std::size_t... I, class /*Enable*/ = typename std::enable_if<!std::is_copy_constructible<T>::value>::type>
+constexpr auto assert_first_not_base(std::index_sequence<I0, I...>) noexcept
+    -> typename std::add_pointer<decltype(T{ ubiq_rref_base_asserting<T>{}, ubiq_rref_constructor{I}... })>::type
+{
+    return nullptr;
+}
+
+template <class T>
+constexpr void* assert_first_not_base(std::index_sequence<>) noexcept
+{
+    return nullptr;
+}
+
 ///////////////////// Helper for SFINAE on fields count
 template <class T, std::size_t... I, class /*Enable*/ = typename std::enable_if<std::is_copy_constructible<T>::value>::type>
 constexpr auto enable_if_constructible_helper(std::index_sequence<I...>) noexcept
@@ -187,7 +254,7 @@ constexpr std::size_t detect_fields_count_dispatch(size_t_<N>, int, int) noexcep
     return detail::detect_fields_count_greedy<T, 0, N>(detail::multi_element_range{});
 }
 
-///////////////////// Returns non-flattened fields count
+///////////////////// Returns fields count
 template <class T>
 constexpr std::size_t fields_count() noexcept {
     using type = std::remove_cv_t<T>;
@@ -197,6 +264,7 @@ constexpr std::size_t fields_count() noexcept {
         "====================> 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."
     );
 
+#if !BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
     static_assert(
         std::is_copy_constructible<std::remove_all_extents_t<type>>::value || (
             std::is_move_constructible<std::remove_all_extents_t<type>>::value
@@ -204,6 +272,7 @@ constexpr std::size_t fields_count() noexcept {
         ),
         "====================> Boost.PFR: Type and each field in the type must be copy constructible (or move constructible and move assignable)."
     );
+#endif  // #if !BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
 
     static_assert(
         !std::is_polymorphic<type>::value,
@@ -212,8 +281,8 @@ constexpr std::size_t fields_count() noexcept {
 
 #ifdef __cpp_lib_is_aggregate
     static_assert(
-        std::is_aggregate<type>::value             // Does not return `true` for build in types.
-        || std::is_standard_layout<type>::value,   // Does not return `true` for structs that have non standard layout members.
+        std::is_aggregate<type>::value             // Does not return `true` for built-in types.
+        || std::is_scalar<type>::value,
         "====================> Boost.PFR: Type must be aggregate initializable."
     );
 #endif
@@ -226,13 +295,23 @@ constexpr std::size_t fields_count() noexcept {
 //    );
 //#endif
 
+#if defined(_MSC_VER) && (_MSC_VER <= 1920)
+    // Workaround for msvc compilers. Versions <= 1920 have a limit of max 1024 elements in template parameter pack
+    constexpr std::size_t max_fields_count = (sizeof(type) * CHAR_BIT >= 1024 ? 1024 : sizeof(type) * CHAR_BIT);
+#else
     constexpr std::size_t max_fields_count = (sizeof(type) * CHAR_BIT); // We multiply by CHAR_BIT because the type may have bitfields in T
+#endif
+
     constexpr std::size_t result = detail::detect_fields_count_dispatch<type>(size_t_<max_fields_count>{}, 1L, 1L);
 
+    detail::assert_first_not_base<type>(detail::make_index_sequence<result>{});
+
+#ifndef __cpp_lib_is_aggregate
     static_assert(
         is_aggregate_initializable_n<type, result>::value,
         "====================> Boost.PFR: Types with user specified constructors (non-aggregate initializable types) are not supported."
     );
+#endif
 
     static_assert(
         result != 0 || std::is_empty<type>::value || std::is_fundamental<type>::value || std::is_reference<type>::value,

include/boost/pfr/detail/flat_tie_from_structure_tuple.hpp

@@ -1,41 +0,0 @@
-// Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_DETAIL_FLAT_TIE_FROM_STRUCTURE_TUPLE_HPP
-#define BOOST_PFR_DETAIL_FLAT_TIE_FROM_STRUCTURE_TUPLE_HPP
-#pragma once
-
-#include <boost/pfr/detail/stdtuple.hpp>
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/detail/core14.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
-
-namespace boost { namespace pfr { namespace detail {
-
-/// \brief A `std::tuple` capable of de-structuring assignment used to support
-/// a tie of multiple lvalue references to \flattening{flattened} fields of an
-/// aggregate T.
-///
-/// \sa boost::pfr::flat_tie_from_structure
-///
-template <typename... Elements>
-struct flat_tie_from_structure_tuple : std::tuple<Elements&...> {
-    using base = std::tuple<Elements&...>;
-    using base::base;
-
-    template <typename T>
-    constexpr flat_tie_from_structure_tuple& operator= (T const& t) {
-        base::operator=(
-            detail::make_stdtiedtuple_from_tietuple(
-                detail::tie_as_flat_tuple(t),
-                detail::make_index_sequence<flat_tuple_size_v<T>>()));
-        return *this;
-    }
-};
-
-}}} // boost::pfr::detail
-
-#endif // BOOST_PFR_DETAIL_FLAT_TIE_FROM_STRUCTURE_TUPLE_HPP

include/boost/pfr/detail/for_each_field_impl.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -29,9 +29,10 @@ void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
     std::forward<F>(f)(std::forward<T>(v));
 }
 
+#if !defined(__cpp_fold_expressions) || __cpp_fold_expressions < 201603
 template <class T, class F, std::size_t... I>
 void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
-     const int v[] = {(
+     const int v[] = {0, (
          detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
          0
      )...};
@@ -41,12 +42,23 @@ void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type
 
 template <class T, class F, std::size_t... I>
 void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
-     const int v[] = {(
+     const int v[] = {0, (
          detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
          0
      )...};
      (void)v;
 }
+#else
+template <class T, class F, std::size_t... I>
+void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
+     (detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L), ...);
+}
+
+template <class T, class F, std::size_t... I>
+void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
+     (detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L), ...);
+}
+#endif
 
 }}} // namespace boost::pfr::detail
 

include/boost/pfr/detail/functional.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,6 +10,7 @@
 #include <boost/pfr/detail/config.hpp>
 
 #include <functional>
+#include <cstdint>
 
 #include <boost/pfr/detail/sequence_tuple.hpp>
 
@@ -116,17 +117,75 @@ namespace boost { namespace pfr { namespace detail {
         }
     };
 
+    // Hash combine functions copied from Boost.ContainerHash
+    // https://github.com/boostorg/container_hash/blob/171c012d4723c5e93cc7cffe42919afdf8b27dfa/include/boost/container_hash/hash.hpp#L311
+    // that is based on Peter Dimov's proposal
+    // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+    // issue 6.18.
+    //
+    // This also contains public domain code from MurmurHash. From the
+    // MurmurHash header:
+    //
+    // MurmurHash3 was written by Austin Appleby, and is placed in the public
+    // domain. The author hereby disclaims copyright to this source code.
     template <typename SizeT>
     constexpr void hash_combine(SizeT& seed, SizeT value) noexcept {
         seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
     }
 
+    constexpr auto rotl(std::uint32_t x, std::uint32_t r) noexcept {
+        return (x << r) | (x >> (32 - r));
+    }
+
+    constexpr void hash_combine(std::uint32_t& h1, std::uint32_t k1) noexcept {
+          const std::uint32_t c1 = 0xcc9e2d51;
+          const std::uint32_t c2 = 0x1b873593;
+
+          k1 *= c1;
+          k1 = detail::rotl(k1,15);
+          k1 *= c2;
+
+          h1 ^= k1;
+          h1 = detail::rotl(h1,13);
+          h1 = h1*5+0xe6546b64;
+    }
+
+#if defined(INT64_MIN) && defined(UINT64_MAX)
+    constexpr void hash_combine(std::uint64_t& h, std::uint64_t k) noexcept {
+        const std::uint64_t m = 0xc6a4a7935bd1e995ULL;
+        const int r = 47;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+
+        // Completely arbitrary number, to prevent 0's
+        // from hashing to 0.
+        h += 0xe6546b64;
+    }
+#endif
+
+    template <typename T>
+    auto compute_hash(const T& value, long /*priority*/)
+        -> decltype(std::hash<T>()(value))
+    {
+        return std::hash<T>()(value);
+    }
+
+    template <typename T>
+    std::size_t compute_hash(const T& /*value*/, int /*priority*/) {
+        static_assert(sizeof(T) && false, "====================> Boost.PFR: std::hash not specialized for type T");
+        return 0;
+    }
+
     template <std::size_t I, std::size_t N>
     struct hash_impl {
         template <class T>
         constexpr static std::size_t compute(const T& val) noexcept {
-            typedef std::decay_t<typename detail::sequence_tuple::tuple_element<I, T>::type> elem_t;
-            std::size_t h = std::hash<elem_t>()( ::boost::pfr::detail::sequence_tuple::get<I>(val) );
+            std::size_t h = detail::compute_hash( ::boost::pfr::detail::sequence_tuple::get<I>(val), 1L );
             detail::hash_combine(h, hash_impl<I + 1, N>::compute(val) );
             return h;
         }
@@ -145,6 +204,36 @@ namespace boost { namespace pfr { namespace detail {
         return x < y ? x : y;
     }
 
+    template <template <std::size_t, std::size_t> class Visitor, class T, class U>
+    constexpr bool binary_visit(const T& x, const U& y) {
+        constexpr std::size_t fields_count_lhs = detail::fields_count<std::remove_reference_t<T>>();
+        constexpr std::size_t fields_count_rhs = detail::fields_count<std::remove_reference_t<U>>();
+        constexpr std::size_t fields_count_min = detail::min_size(fields_count_lhs, fields_count_rhs);
+        typedef Visitor<0, fields_count_min> visitor_t;
+
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+        return visitor_t::cmp(detail::tie_as_tuple(x), detail::tie_as_tuple(y));
+#else
+        bool result = true;
+        ::boost::pfr::detail::for_each_field_dispatcher(
+            x,
+            [&result, &y](const auto& lhs) {
+                constexpr std::size_t fields_count_rhs_ = detail::fields_count<std::remove_reference_t<U>>();
+                ::boost::pfr::detail::for_each_field_dispatcher(
+                    y,
+                    [&result, &lhs](const auto& rhs) {
+                        result = visitor_t::cmp(lhs, rhs);
+                    },
+                    detail::make_index_sequence<fields_count_rhs_>{}
+                );
+            },
+            detail::make_index_sequence<fields_count_lhs>{}
+        );
+
+        return result;
+#endif
+    }
+
 }}} // namespace boost::pfr::detail
 
 #endif // BOOST_PFR_DETAIL_FUNCTIONAL_HPP

include/boost/pfr/detail/io.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/pfr/detail/make_flat_tuple_of_references.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/pfr/detail/make_integer_sequence.hpp

@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Sergei Fedorov
-// Copyright (c) 2019-2020 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -46,7 +46,7 @@ struct join_sequences<std::integer_sequence<T, A...>, std::integer_sequence<T, B
 
 template <typename T, T Min, T Max>
 struct build_sequence_impl {
-    static_assert(Min < Max, "Start of range must be less than it's end");
+    static_assert(Min < Max, "Start of range must be less than its end");
     static constexpr T size = Max - Min;
     using type = typename join_sequences<
             typename build_sequence_impl<T, Min, Min + size / 2>::type,

include/boost/pfr/detail/offset_based_getter.hpp

@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Chris Beck
-// Copyright (c) 2019-2020 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,15 +12,14 @@
 
 #include <type_traits>
 #include <utility>
+#include <memory>  // std::addressof
 #include <boost/pfr/detail/sequence_tuple.hpp>
 #include <boost/pfr/detail/rvalue_t.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
 
 
 namespace boost { namespace pfr { namespace detail {
 
-template <std::size_t Index>
-using size_t_ = std::integral_constant<std::size_t, Index >;
-
 // Our own implementation of std::aligned_storage. On godbolt with MSVC, I have compilation errors
 // using the standard version, it seems the compiler cannot generate default ctor.
 
@@ -69,7 +68,7 @@ template <typename U, typename S>
 class offset_based_getter {
   using this_t = offset_based_getter<U, S>;
 
-  static_assert(sizeof(U) == sizeof(S), "====================> Boost.PFR: Member sequence does not indicate correct size for struct type!");
+  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?");
   static_assert(alignof(U) == alignof(S), "====================> Boost.PFR: Member sequence does not indicate correct alignment for struct type!");
 
   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");

include/boost/pfr/detail/possible_reflectable.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+#define BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/traits_fwd.hpp>
+
+#include <type_traits> // for std::is_aggregate
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// Returns false when the type exactly wasn't be reflectable
+template <class T, class WhatFor>
+constexpr decltype(is_reflectable<T, WhatFor>::value) possible_reflectable(long) noexcept {
+    return is_reflectable<T, WhatFor>::value;
+}
+
+#if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+
+template <class T, class WhatFor>
+constexpr bool possible_reflectable(int) noexcept {
+#   if  defined(__cpp_lib_is_aggregate)
+    using type = std::remove_cv_t<T>;
+    return std::is_aggregate<type>();
+#   else
+    return true;
+#   endif
+}
+
+#else
+
+template <class T, class WhatFor>
+constexpr bool possible_reflectable(int) noexcept {
+    // negative answer here won't change behaviour in PFR-dependent libraries(like Fusion)
+    return false;
+}
+
+#endif
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+
+

include/boost/pfr/detail/rvalue_t.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/pfr/detail/sequence_tuple.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -13,7 +13,7 @@
 #include <utility>      // metaprogramming stuff
 #include <cstddef>      // std::size_t
 
-///////////////////// Tuple that holds it's values in the supplied order
+///////////////////// Tuple that holds its values in the supplied order
 namespace boost { namespace pfr { namespace detail { namespace sequence_tuple {
 
 template <std::size_t N, class T>
@@ -50,30 +50,74 @@ struct tuple_base<std::index_sequence<> > {
 
 template <std::size_t N, class T>
 constexpr T& get_impl(base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
     return t.value;
 }
 
 template <std::size_t N, class T>
 constexpr const T& get_impl(const base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
     return t.value;
 }
 
 template <std::size_t N, class T>
 constexpr volatile T& get_impl(volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
     return t.value;
 }
 
 template <std::size_t N, class T>
 constexpr const volatile T& get_impl(const volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
     return t.value;
 }
 
 template <std::size_t N, class T>
 constexpr T&& get_impl(base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
     return std::forward<T>(t.value);
 }
 
 
+template <class T, std::size_t N>
+constexpr T& get_by_type_impl(base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr const T& get_by_type_impl(const base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr volatile T& get_by_type_impl(volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr const volatile T& get_by_type_impl(const volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr T&& get_by_type_impl(base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return std::forward<T>(t.value);
+}
+
+template <class T, std::size_t N>
+constexpr const T&& get_by_type_impl(const base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return std::forward<T>(t.value);
+}
+
+
+
+
 template <class ...Values>
 struct tuple: tuple_base<
     detail::index_sequence_for<Values...>,

include/boost/pfr/detail/size_array.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

include/boost/pfr/detail/size_t_.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_SIZE_T_HPP
+#define BOOST_PFR_DETAIL_SIZE_T_HPP
+#pragma once
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// General utility stuff
+template <std::size_t Index>
+using size_t_ = std::integral_constant<std::size_t, Index >;
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_SIZE_T_HPP

include/boost/pfr/detail/stdtuple.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,6 +30,17 @@ constexpr auto make_stdtiedtuple_from_tietuple(const T& t, std::index_sequence<I
     );
 }
 
+template <class T, std::size_t... I>
+constexpr auto make_conststdtiedtuple_from_tietuple(const T& t, std::index_sequence<I...>) noexcept {
+    return std::tuple<
+        std::add_lvalue_reference_t<std::add_const_t<
+            std::remove_reference_t<decltype(boost::pfr::detail::sequence_tuple::get<I>(t))>
+        >>...
+    >(
+        boost::pfr::detail::sequence_tuple::get<I>(t)...
+    );
+}
+
 }}} // namespace boost::pfr::detail
 
 #endif // BOOST_PFR_DETAIL_STDTUPLE_HPP

include/boost/pfr/detail/tie_from_structure_tuple.hpp

@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2020 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -8,14 +8,13 @@
 #define BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP
 #pragma once
 
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
 #include <boost/pfr/detail/stdtuple.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
+#include <boost/pfr/tuple_size.hpp>
 #include <boost/pfr/detail/make_integer_sequence.hpp>
-#if BOOST_PFR_USE_CPP17
-#   include <boost/pfr/detail/core17.hpp>
-#else
-#   include <boost/pfr/detail/core14.hpp>
-#endif
 
 #include <tuple>
 
@@ -40,6 +39,6 @@ struct tie_from_structure_tuple : std::tuple<Elements&...> {
     }
 };
 
-}}} // boost::pfr::detail
+}}} // namespace boost::pfr::detail
 
 #endif // BOOST_PFR_DETAIL_TIE_FROM_STRUCTURE_TUPLE_HPP

include/boost/pfr/detail/unsafe_declval.hpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2019-2023 Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+#define BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <type_traits>
+
+namespace boost { namespace pfr { namespace detail {
+
+// This function serves as a link-time assert. If linker requires it, then
+// `unsafe_declval()` is used at runtime.
+void report_if_you_see_link_error_with_this_function() noexcept;
+
+// For returning non default constructible types. Do NOT use at runtime!
+//
+// GCCs std::declval may not be used in potentionally evaluated contexts,
+// so we reinvent it.
+template <class T>
+constexpr T unsafe_declval() noexcept {
+    report_if_you_see_link_error_with_this_function();
+
+    typename std::remove_reference<T>::type* ptr = nullptr;
+    ptr += 42; // suppresses 'null pointer dereference' warnings
+    return static_cast<T>(*ptr);
+}
+
+}}} // namespace boost::pfr::detail
+
+
+#endif // BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+

include/boost/pfr/flat.hpp

@@ -1,19 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_HPP
-#define BOOST_PFR_FLAT_HPP
-
-/// \file boost/pfr/flat.hpp
-/// Includes all the Boost.PFR headers that define `flat_*` functions, except \xmlonly<link linkend='header.boost.pfr.flat.global_ops_hpp'>boost/pfr/flat/global_ops.hpp</link>\endxmlonly
-
-#include <boost/pfr/flat/core.hpp>
-#include <boost/pfr/flat/functors.hpp>
-#include <boost/pfr/flat/ops.hpp>
-#include <boost/pfr/flat/io.hpp>
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/flat/functions_for.hpp>
-
-#endif // BOOST_PFR_FLAT_HPP

include/boost/pfr/flat/core.hpp

@@ -1,161 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_CORE_HPP
-#define BOOST_PFR_FLAT_CORE_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <type_traits>
-#include <utility>      // metaprogramming stuff
-
-#include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/stdtuple.hpp>
-#include <boost/pfr/detail/core14.hpp>
-#include <boost/pfr/detail/for_each_field_impl.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
-#include <boost/pfr/flat/tuple_size.hpp>
-
-#include <boost/pfr/detail/flat_tie_from_structure_tuple.hpp>
-
-namespace boost { namespace pfr {
-
-/// \brief Returns reference or const reference to a field with index `I` in \flattening{flattened} T.
-///
-/// \rcast
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s {10, 11};
-///     assert(boost::pfr::flat_get<0>(s) == 10);
-///     boost::pfr::flat_get<1>(s) = 0;
-/// \endcode
-template <std::size_t I, class T>
-decltype(auto) flat_get(const T& val) noexcept {
-    return boost::pfr::detail::sequence_tuple::get<I>( boost::pfr::detail::tie_as_flat_tuple(val) );
-}
-
-
-/// \overload flat_get
-template <std::size_t I, class T>
-decltype(auto) flat_get(T& val /* @cond */, std::enable_if_t< std::is_trivially_assignable<T, T>::value>* = 0/* @endcond */ ) noexcept {
-    return boost::pfr::detail::sequence_tuple::get<I>( boost::pfr::detail::tie_as_flat_tuple(val) );
-}
-
-
-/// \brief `flat_tuple_element` has a `typedef type-of-the-field-with-index-I-in-\flattening{flattened}-T type;`
-///
-/// \b Example:
-/// \code
-///     std::vector<  boost::pfr::flat_tuple_element<0, my_structure>::type  > v;
-/// \endcode
-template <std::size_t I, class T>
-using flat_tuple_element = std::remove_reference<
-        typename boost::pfr::detail::sequence_tuple::tuple_element<I, decltype(boost::pfr::detail::tie_as_flat_tuple(std::declval<T&>())) >::type
-    >;
-
-
-/// \brief Type of a field with index `I` in \flattening{flattened} `T`
-///
-/// \b Example:
-/// \code
-///     std::vector<  boost::pfr::flat_tuple_element_t<0, my_structure>  > v;
-/// \endcode
-template <std::size_t I, class T>
-using flat_tuple_element_t = typename flat_tuple_element<I, T>::type;
-
-
-/// \brief Creates an `std::tuple` from a \flattening{flattened} T.
-///
-/// \rcast
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s {10, 11};
-///     std::tuple<int, short> t = flat_make_tuple(s);
-///     assert(flat_get<0>(t) == 10);
-/// \endcode
-template <class T>
-auto flat_structure_to_tuple(const T& val) noexcept {
-    return detail::make_stdtuple_from_tietuple(
-        detail::tie_as_flat_tuple(val),
-        detail::make_index_sequence< flat_tuple_size_v<T> >()
-    );
-}
-
-
-/// \brief Creates an `std::tuple` with lvalue references to fields of a \flattening{flattened} T.
-///
-/// \rcast
-///
-/// \b Requires: `T` must not have const fields.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s;
-///     flat_structure_tie(s) = std::tuple<int, short>{10, 11};
-///     assert(s.s == 11);
-/// \endcode
-template <class T>
-auto flat_structure_tie(T& val /* @cond */, std::enable_if_t< std::is_trivially_assignable<T, T>::value>* = 0 /* @endcond */) noexcept {
-    return detail::make_stdtiedtuple_from_tietuple(
-        detail::tie_as_flat_tuple(val),
-        detail::make_index_sequence< flat_tuple_size_v<T> >()
-    );
-}
-
-/// Calls `func` for each field of a \flattening{flattened} POD `value`.
-///
-/// \rcast
-///
-/// \param func must have one of the following signatures:
-///     * any_return_type func(U&& field)                // field of value is perfect forwarded to function
-///     * any_return_type func(U&& field, std::size_t i)
-///     * any_return_type func(U&& value, I i)  // Here I is an `std::integral_constant<size_t, field_index>`
-///
-/// \param value After \flattening{flattening} to each field of this variable will be the `func` applied.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     int sum = 0;
-///     for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
-///     assert(sum == 42);
-/// \endcode
-template <class T, class F>
-void flat_for_each_field(T&& value, F&& func) {
-    auto tup = detail::tie_as_flat_tuple(value);
-    ::boost::pfr::detail::for_each_field_impl(
-        tup,
-        std::forward<F>(func),
-        detail::make_index_sequence< flat_tuple_size_v<T> >{},
-        std::is_rvalue_reference<T&&>{}
-    );
-}
-
-/// \brief Create a tuple of lvalue references capable of de-structuring
-/// assignment from \flattening{flattened} fields of an aggregate T.
-///
-/// \b Example:
-/// \code
-///     auto f() {
-///       struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 };
-///       return res;
-///     }
-///     auto [x, y, s] = flat_structure_tie(f());
-///     flat_tie_from_structure(x, y, s) = f();
-/// \endcode
-template <typename... Elements>
-constexpr detail::flat_tie_from_structure_tuple<Elements...> flat_tie_from_structure(Elements&... args) noexcept {
-    return detail::flat_tie_from_structure_tuple<Elements...>(args...);
-}
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_FLAT_CORE_HPP

include/boost/pfr/flat/functions_for.hpp

@@ -1,81 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_FUNCTIONS_FOR_HPP
-#define BOOST_PFR_FLAT_FUNCTIONS_FOR_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/flat/functors.hpp>
-#include <boost/pfr/flat/io.hpp>
-
-/// \def BOOST_PFR_FLAT_FUNCTIONS_FOR(T)
-/// Defines comparison operators and stream operators for T.
-/// If POD is comparable or streamable using it's own operator (but not it's conversion operator), then the original operator is used.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/flat/functions_for.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     BOOST_PFR_FLAT_FUNCTIONS_FOR(comparable_struct)
-///     // ...
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \rcast
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b Defines \b following \b for \b T:
-/// \code
-/// bool operator==(const T& lhs, const T& rhs) noexcept;
-/// bool operator!=(const T& lhs, const T& rhs) noexcept;
-/// bool operator< (const T& lhs, const T& rhs) noexcept;
-/// bool operator> (const T& lhs, const T& rhs) noexcept;
-/// bool operator<=(const T& lhs, const T& rhs) noexcept;
-/// bool operator>=(const T& lhs, const T& rhs) noexcept;
-///
-/// template <class Char, class Traits>
-/// std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-///
-/// template <class Char, class Traits>
-/// std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-///
-/// // helper function for Boost unordered containers and boost::hash<>.
-/// std::size_t hash_value(const T& value) noexcept;
-/// \endcode
-
-#define BOOST_PFR_FLAT_FUNCTIONS_FOR(T)                                                                                           \
-    static inline bool operator==(const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_equal_to<T>{}(lhs, rhs);      }  \
-    static inline bool operator!=(const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_not_equal<T>{}(lhs, rhs);     }  \
-    static inline bool operator< (const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_less<T>{}(lhs, rhs);          }  \
-    static inline bool operator> (const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_greater<T>{}(lhs, rhs);       }  \
-    static inline bool operator<=(const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_less_equal<T>{}(lhs, rhs);    }  \
-    static inline bool operator>=(const T& lhs, const T& rhs) noexcept { return ::boost::pfr::flat_greater_equal<T>{}(lhs, rhs); }  \
-    template <class Char, class Traits>                                                                                             \
-    static ::std::basic_ostream<Char, Traits>& operator<<(::std::basic_ostream<Char, Traits>& out, const T& value) {                \
-        ::boost::pfr::flat_write(out, value);                                                                                       \
-        return out;                                                                                                                 \
-    }                                                                                                                               \
-    template <class Char, class Traits>                                                                                             \
-    static ::std::basic_istream<Char, Traits>& operator>>(::std::basic_istream<Char, Traits>& in, T& value) {                       \
-        ::boost::pfr::flat_read(in, value);                                                                                         \
-        return in;                                                                                                                  \
-    }                                                                                                                               \
-    static inline std::size_t hash_value(const T& v) noexcept {                                                                     \
-        return ::boost::pfr::flat_hash<T>{}(v);                                                                                     \
-    }                                                                                                                               \
-/**/
-
-#endif // BOOST_PFR_FLAT_FUNCTIONS_FOR_HPP
-
-

include/boost/pfr/flat/functors.hpp

@@ -1,233 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_FUNCTORS_HPP
-#define BOOST_PFR_FLAT_FUNCTORS_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/detail/functional.hpp>
-#include <boost/pfr/flat/core.hpp>
-
-/// \file boost/pfr/functors.hpp
-/// Contains functors that can work with PODs and are close to the Standard Library ones.
-/// Each functor \flattening{flattens} the POD type and iterates over its fields.
-///
-/// \rcast
-
-namespace boost { namespace pfr {
-///////////////////// Comparisons
-
-/// \brief std::equal_to like flattening comparator
-template <class T = void> struct flat_equal_to {
-    /// \return \b true if each field of \b x equals the field with same index of \b y.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::equal_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_equal_to<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::equal_impl<
-            0,
-            detail::min_size(flat_tuple_size_v<T>, flat_tuple_size_v<U>)
-        >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-};
-/// @endcond
-
-/// \brief std::not_equal like flattening comparator
-template <class T = void> struct flat_not_equal {
-    /// \return \b true if at least one field \b x not equals the field with same index of \b y.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::not_equal_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_not_equal<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::not_equal_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-    typedef std::true_type is_transparent;
-};
-/// @endcond
-
-/// \brief std::greater like flattening comparator
-template <class T = void> struct flat_greater {
-    /// \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.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::greater_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_greater<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::greater_impl<
-            0,
-            detail::min_size(flat_tuple_size_v<T>, flat_tuple_size_v<U>)
-        >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-    typedef std::true_type is_transparent;
-};
-/// @endcond
-
-/// \brief std::less like flattening comparator
-template <class T = void> struct flat_less {
-    /// \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.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::less_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_less<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::less_impl<
-            0,
-            detail::min_size(flat_tuple_size_v<T>, flat_tuple_size_v<U>)
-        >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-    typedef std::true_type is_transparent;
-};
-/// @endcond
-
-/// \brief std::greater_equal like flattening comparator
-template <class T = void> struct flat_greater_equal {
-    /// \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;
-    /// or if each field of \b x equals the field with same index of \b y.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::greater_equal_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_greater_equal<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::greater_equal_impl<
-            0,
-            detail::min_size(flat_tuple_size_v<T>, flat_tuple_size_v<U>)
-        >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-    typedef std::true_type is_transparent;
-};
-/// @endcond
-
-/// \brief std::less_equal like flattening comparator
-template <class T = void> struct flat_less_equal {
-    /// \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;
-    /// or if each field of \b x equals the field with same index of \b y.
-    ///
-    /// \rcast
-    bool operator()(const T& x, const T& y) const noexcept {
-        return detail::less_equal_impl<0, flat_tuple_size_v<T> >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    /// This typedef exists only if T \b is void
-    typedef std::true_type is_transparent;
-
-    /// This operator allows comparison of \b x and \b y that have different type.
-    /// \pre Exists only if T \b is void.
-    template <class V, class U> bool operator()(const V& x, const U& y) const noexcept;
-#endif
-};
-
-/// @cond
-template <> struct flat_less_equal<void> {
-    template <class T, class U>
-    bool operator()(const T& x, const U& y) const noexcept {
-        return detail::less_equal_impl<
-            0,
-            detail::min_size(flat_tuple_size_v<T>, flat_tuple_size_v<U>)
-        >::cmp(detail::tie_as_flat_tuple(x), detail::tie_as_flat_tuple(y));
-    }
-
-    typedef std::true_type is_transparent;
-};
-/// @endcond
-
-
-/// \brief std::hash like flattening functor
-template <class T> struct flat_hash {
-    /// \return hash value of \b x.
-    ///
-    /// \rcast
-    std::size_t operator()(const T& x) const noexcept {
-        return detail::hash_impl<0, flat_tuple_size_v<T> >::compute(detail::tie_as_flat_tuple(x));
-    }
-};
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_FLAT_FUNCTORS_HPP

include/boost/pfr/flat/global_ops.hpp

@@ -1,116 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_GLOBAL_OPS_HPP
-#define BOOST_PFR_FLAT_GLOBAL_OPS_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/flat/functors.hpp>
-#include <boost/pfr/flat/core.hpp>
-#include <boost/pfr/flat/io.hpp>
-
-/// \file boost/pfr/flat/global_ops.hpp
-/// Contains comparison operators and stream operators for any POD types that do not have their own operators.
-/// If POD is comparable or streamable using it's own operator (but not it's conversion operator), then the original operator is used.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/flat/global_ops.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     // ...
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \rcast
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b This \b header \b defines:
-/// @cond
-namespace boost { namespace pfr { namespace detail {
-
-    template <class T, class U>
-    using enable_flat_comparisons = std::enable_if_t<
-        std::is_same<T, U>::value && std::is_pod<T>::value,
-        bool
-    >;
-
-}}} // namespace boost::pfr::detail
-/// @endcond
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    template <class T> bool operator==(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator!=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator< (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator> (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator<=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator>=(const T& lhs, const T& rhs) noexcept;
-
-    template <class Char, class Traits, class T>
-    std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-
-    template <class Char, class Traits, class T>
-    std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-
-    /// \brief helper function for Boost unordered containers and boost::hash<>.
-    template <class T> std::size_t hash_value(const T& value) noexcept;
-#else
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator==(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_equal_to<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator!=(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_not_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator<(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_less<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator>(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_greater<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator<=(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_less_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_flat_comparisons<T, U> operator>=(const T& lhs, const U& rhs) noexcept {
-        return ::boost::pfr::flat_greater_equal<T>{}(lhs, rhs);
-    }
-
-    template <class Char, class Traits, class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::basic_ostream<Char, Traits>&> operator<<(std::basic_ostream<Char, Traits>& out, const T& value) {
-        ::boost::pfr::flat_write(out, value);
-        return out;
-    }
-
-    template <class Char, class Traits, class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::basic_istream<Char, Traits>&> operator>>(std::basic_istream<Char, Traits>& in, T& value) {
-        ::boost::pfr::flat_read(in, value);
-        return in;
-    }
-
-    template <class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::size_t> hash_value(const T& value) noexcept {
-        return ::boost::pfr::flat_hash<T>{}(value);
-    }
-#endif
-
-#endif // BOOST_PFR_FLAT_GLOBAL_OPS_HPP

include/boost/pfr/flat/io.hpp

@@ -1,75 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_IO_HPP
-#define BOOST_PFR_FLAT_IO_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <type_traits>
-#include <utility>      // metaprogramming stuff
-
-#include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/io.hpp>
-#include <boost/pfr/detail/core14.hpp>
-#include <boost/pfr/flat/tuple_size.hpp>
-
-namespace boost { namespace pfr {
-
-/// \brief Writes \flattening{flattened} POD `value` to `out`
-///
-/// \rcast
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s{12, 13};
-///     flat_write(std::cout, s); // outputs '{12, 13}'
-/// \endcode
-template <class Char, class Traits, class T>
-void flat_write(std::basic_ostream<Char, Traits>& out, const T& value) {
-    out << '{';
-    detail::print_impl<0, flat_tuple_size_v<T> >::print(out, detail::tie_as_flat_tuple(value));
-    out << '}';
-}
-
-/// Reads \flattening{flattened} POD `value` from stream `in`
-///
-/// \rcast
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s;
-///     std::stringstream ss;
-///     ss << "{ 12, 13 }";
-///     ss >> s;
-///     assert(s.i == 12);
-///     assert(s.i == 13);
-/// \endcode
-template <class Char, class Traits, class T>
-void flat_read(std::basic_istream<Char, Traits>& in, T& value) {
-    const auto prev_exceptions = in.exceptions();
-    in.exceptions( typename std::basic_istream<Char, Traits>::iostate(0) );
-    const auto prev_flags = in.flags( typename std::basic_istream<Char, Traits>::fmtflags(0) );
-
-    char parenthis = {};
-    in >> parenthis;
-    if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
-
-    auto tuple = detail::tie_as_flat_tuple(value);
-    detail::read_impl<0, flat_tuple_size_v<T> >::read(in, tuple);
-
-    in >> parenthis;
-    if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
-
-    in.flags(prev_flags);
-    in.exceptions(prev_exceptions);
-}
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_FLAT_IO_HPP

include/boost/pfr/flat/ops.hpp

@@ -1,146 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_OPS_HPP
-#define BOOST_PFR_FLAT_OPS_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/detail/detectors.hpp>
-#include <boost/pfr/flat/functors.hpp>
-#include <boost/pfr/flat/io.hpp>
-
-/// \file boost/pfr/flat/ops.hpp
-/// Contains comparison operators and stream operators for any POD types that do not have their own operators.
-/// If POD is comparable or streamable using it's own operator or it's conversion operator, then the original operator is used.
-///
-/// Just write \b using \b namespace \b flat_ops; and operators will be available in scope.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/flat/ops.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     // ...
-///
-///     using namespace flat_ops;
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \rcast
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b This \b header \b contains:
-namespace boost { namespace pfr { 
-
-namespace detail {
-
-///////////////////// Helper typedef that it used by all the enable_flat_not_*_comp_t
-    template <template <class, class> class Detector, class T>
-    using enable_flat_not_comp_base_t = typename std::enable_if<
-        not_appliable<Detector, T const&, T const&>::value && std::is_pod<T>::value,
-        bool
-    >::type;
-
-///////////////////// std::enable_if_t like functions that enable only if types do not support operation and are PODs
-
-    template <class T> using enable_flat_not_eq_comp_t = enable_flat_not_comp_base_t<comp_eq_detector, T>;
-    template <class T> using enable_flat_not_ne_comp_t = enable_flat_not_comp_base_t<comp_ne_detector, T>;
-    template <class T> using enable_flat_not_lt_comp_t = enable_flat_not_comp_base_t<comp_lt_detector, T>;
-    template <class T> using enable_flat_not_le_comp_t = enable_flat_not_comp_base_t<comp_le_detector, T>;
-    template <class T> using enable_flat_not_gt_comp_t = enable_flat_not_comp_base_t<comp_gt_detector, T>;
-    template <class T> using enable_flat_not_ge_comp_t = enable_flat_not_comp_base_t<comp_ge_detector, T>;
-
-    template <class Stream, class Type>
-    using enable_flat_not_ostreamable_t = typename std::enable_if<
-        not_appliable<ostreamable_detector, Stream&, Type const&>::value && std::is_pod<Type>::value,
-        Stream&
-    >::type;
-
-    template <class Stream, class Type>
-    using enable_flat_not_istreamable_t = typename std::enable_if<
-        not_appliable<istreamable_detector, Stream&, Type&>::value && std::is_pod<Type>::value,
-        Stream&
-    >::type;
-} // namespace detail
-
-namespace flat_ops {
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    template <class T> bool operator==(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator!=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator< (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator> (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator<=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator>=(const T& lhs, const T& rhs) noexcept;
-
-    template <class Char, class Traits, class T>
-    std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-
-    template <class Char, class Traits, class T>
-    std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-
-    /// \brief helper function for Boost
-    template <class T> std::size_t hash_value(const T& value) noexcept;
-#else
-    template <class T>
-    static detail::enable_flat_not_eq_comp_t<T> operator==(const T& lhs, const T& rhs) noexcept {
-        return flat_equal_to<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_flat_not_ne_comp_t<T> operator!=(const T& lhs, const T& rhs) noexcept {
-        return flat_not_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_flat_not_lt_comp_t<T> operator<(const T& lhs, const T& rhs) noexcept {
-        return flat_less<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_flat_not_gt_comp_t<T> operator>(const T& lhs, const T& rhs) noexcept {
-        return flat_greater<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_flat_not_le_comp_t<T> operator<=(const T& lhs, const T& rhs) noexcept {
-        return flat_less_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_flat_not_ge_comp_t<T> operator>=(const T& lhs, const T& rhs) noexcept {
-        return flat_greater_equal<T>{}(lhs, rhs);
-    }
-
-    template <class Char, class Traits, class T>
-    static detail::enable_flat_not_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, const T& value) {
-        boost::pfr::flat_write(out, value);
-        return out;
-    }
-
-    template <class Char, class Traits, class T>
-    static detail::enable_flat_not_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, T& value) {
-        boost::pfr::flat_read(in, value);
-        return in;
-    }
-
-    template <class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::size_t> hash_value(const T& value) noexcept {
-        return flat_hash<T>{}(value);
-    }
-
-#endif
-} // namespace flat_ops
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_FLAT_OPS_HPP

include/boost/pfr/flat/tuple_size.hpp

@@ -1,40 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_FLAT_TUPLE_SIZE_HPP
-#define BOOST_PFR_FLAT_TUPLE_SIZE_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <utility>      // metaprogramming stuff
-
-#include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/core14.hpp>
-
-namespace boost { namespace pfr {
-
-/// Has a static const member variable `value` that contains fields count in a \flattening{flattened} T.
-///
-/// \b Example:
-/// \code
-///     std::array<int, boost::pfr::flat_tuple_size<my_structure>::value > a;
-/// \endcode
-template <class T>
-using flat_tuple_size = boost::pfr::detail::size_t_<decltype(boost::pfr::detail::tie_as_flat_tuple(std::declval<T&>()))::size_v>;
-
-
-/// `flat_tuple_size_v` is a template variable that contains fields count in a \flattening{flattened} T.
-///
-/// \b Example:
-/// \code
-///     std::array<int, boost::pfr::flat_tuple_size_v<my_structure> > a;
-/// \endcode
-template <class T>
-constexpr std::size_t flat_tuple_size_v = flat_tuple_size<T>::value;
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_FLAT_TUPLE_SIZE_HPP

include/boost/pfr/functions_for.hpp

@@ -0,0 +1,93 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_FUNCTIONS_FOR_HPP
+#define BOOST_PFR_FUNCTIONS_FOR_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/ops_fields.hpp>
+#include <boost/pfr/io_fields.hpp>
+
+/// \file boost/pfr/functions_for.hpp
+/// Contains BOOST_PFR_FUNCTIONS_FOR macro that defined comparison and stream operators for T along with hash_value function.
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functions_for.hpp>
+///
+///     namespace my_namespace {
+///         struct my_struct {      // No operators defined for that structure
+///             int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///         };
+///         BOOST_PFR_FUNCTIONS_FOR(my_struct)
+///     }
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+
+/// \def BOOST_PFR_FUNCTIONS_FOR(T)
+/// Defines comparison and stream operators for T along with hash_value function.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functions_for.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     BOOST_PFR_FUNCTIONS_FOR(comparable_struct)
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
+///     assert(s1 < s2);
+///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Defines \b following \b for \b T:
+/// \code
+/// bool operator==(const T& lhs, const T& rhs);
+/// bool operator!=(const T& lhs, const T& rhs);
+/// bool operator< (const T& lhs, const T& rhs);
+/// bool operator> (const T& lhs, const T& rhs);
+/// bool operator<=(const T& lhs, const T& rhs);
+/// bool operator>=(const T& lhs, const T& rhs);
+///
+/// template <class Char, class Traits>
+/// std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
+///
+/// template <class Char, class Traits>
+/// std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
+///
+/// // helper function for Boost unordered containers and boost::hash<>.
+/// std::size_t hash_value(const T& value);
+/// \endcode
+
+#define BOOST_PFR_FUNCTIONS_FOR(T)                                                                                                          \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator==(const T& lhs, const T& rhs) { return ::boost::pfr::eq_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator!=(const T& lhs, const T& rhs) { return ::boost::pfr::ne_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator< (const T& lhs, const T& rhs) { return ::boost::pfr::lt_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator> (const T& lhs, const T& rhs) { return ::boost::pfr::gt_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator<=(const T& lhs, const T& rhs) { return ::boost::pfr::le_fields(lhs, rhs); }                 \
+    BOOST_PFR_MAYBE_UNUSED inline bool operator>=(const T& lhs, const T& rhs) { return ::boost::pfr::ge_fields(lhs, rhs); }                 \
+    template <class Char, class Traits>                                                                                                     \
+    BOOST_PFR_MAYBE_UNUSED inline ::std::basic_ostream<Char, Traits>& operator<<(::std::basic_ostream<Char, Traits>& out, const T& value) { \
+        return out << ::boost::pfr::io_fields(value);                                                                                       \
+    }                                                                                                                                       \
+    template <class Char, class Traits>                                                                                                     \
+    BOOST_PFR_MAYBE_UNUSED inline ::std::basic_istream<Char, Traits>& operator>>(::std::basic_istream<Char, Traits>& in, T& value) {        \
+        return in >> ::boost::pfr::io_fields(value);                                                                                        \
+    }                                                                                                                                       \
+    BOOST_PFR_MAYBE_UNUSED inline std::size_t hash_value(const T& v) {                                                                      \
+        return ::boost::pfr::hash_fields(v);                                                                                                \
+    }                                                                                                                                       \
+/**/
+
+#endif // BOOST_PFR_FUNCTIONS_FOR_HPP
+

include/boost/pfr/functors.hpp

@@ -1,69 +1,47 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_PFR_PRECISE_FUNCTORS_HPP
-#define BOOST_PFR_PRECISE_FUNCTORS_HPP
+#ifndef BOOST_PFR_FUNCTORS_HPP
+#define BOOST_PFR_FUNCTORS_HPP
 #pragma once
 
 #include <boost/pfr/detail/config.hpp>
 
+#include <boost/pfr/ops.hpp>
+
 #include <boost/pfr/detail/functional.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
-#if BOOST_PFR_USE_CPP17
-#   include <boost/pfr/detail/core17.hpp>
-#else
-#   include <boost/pfr/detail/core14.hpp>
-#endif
 
 /// \file boost/pfr/functors.hpp
 /// Contains functors that are close to the Standard Library ones.
-/// Each functor iterates over fields of the type.
+/// Each functor calls corresponding Boost.PFR function from boost/pfr/ops.hpp
 ///
-/// \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
+/// \b Example:
+/// \code
+///     #include <boost/pfr/functors.hpp>
+///     struct my_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     std::unordered_set<
+///         my_struct,
+///         boost::pfr::hash<>,
+///         boost::pfr::equal_to<>
+///     > my_set;
+/// \endcode
+///
+/// \b Synopsis:
 namespace boost { namespace pfr {
 
-namespace detail {
-
-    template <template <std::size_t, std::size_t> class Visitor, class T, class U>
-    bool binary_visit(const T& x, const U& y) {
-        constexpr std::size_t fields_count_lhs = detail::fields_count<std::remove_reference_t<T>>();
-        constexpr std::size_t fields_count_rhs = detail::fields_count<std::remove_reference_t<U>>();
-        constexpr std::size_t fields_count_min = detail::min_size(fields_count_lhs, fields_count_rhs);
-        typedef Visitor<0, fields_count_min> visitor_t;
-
-#if BOOST_PFR_USE_CPP17
-        return visitor_t::cmp(detail::tie_as_tuple(x), detail::tie_as_tuple(y));
-#else
-        bool result = true;
-        ::boost::pfr::detail::for_each_field_dispatcher(
-            x,
-            [&result, &y](const auto& lhs) {
-                ::boost::pfr::detail::for_each_field_dispatcher(
-                    y,
-                    [&result, &lhs](const auto& rhs) {
-                        result = visitor_t::cmp(lhs, rhs);
-                    },
-                    detail::make_index_sequence<fields_count_rhs>{}
-                );
-            },
-            detail::make_index_sequence<fields_count_lhs>{}
-        );
-
-        return result;
-#endif
-    }
-
-} // namespace detail
-
 ///////////////////// Comparisons
 
-/// \brief std::equal_to like comparator
+/// \brief std::equal_to like comparator that returns \forcedlink{eq}(x, y)
 template <class T = void> struct equal_to {
     /// \return \b true if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::equal_impl>(x, y);
+        return boost::pfr::eq(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -80,17 +58,18 @@ template <class T = void> struct equal_to {
 template <> struct equal_to<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::equal_impl>(x, y);
+        return boost::pfr::eq(x, y);
     }
 
+    typedef std::true_type is_transparent;
 };
 /// @endcond
 
-/// \brief std::not_equal like comparator
+/// \brief std::not_equal like comparator that returns \forcedlink{ne}(x, y)
 template <class T = void> struct not_equal {
     /// \return \b true if at least one field \b x not equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::not_equal_impl>(x, y);
+        return boost::pfr::ne(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -107,18 +86,18 @@ template <class T = void> struct not_equal {
 template <> struct not_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::not_equal_impl>(x, y);
+        return boost::pfr::ne(x, y);
     }
 
     typedef std::true_type is_transparent;
 };
 /// @endcond
 
-/// \brief std::greater like comparator
+/// \brief std::greater like comparator that returns \forcedlink{gt}(x, y)
 template <class T = void> struct greater {
     /// \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.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::greater_impl>(x, y);
+        return boost::pfr::gt(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -135,18 +114,18 @@ template <class T = void> struct greater {
 template <> struct greater<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::greater_impl>(x, y);
+        return boost::pfr::gt(x, y);
     }
 
     typedef std::true_type is_transparent;
 };
 /// @endcond
 
-/// \brief std::less like comparator
+/// \brief std::less like comparator that returns \forcedlink{lt}(x, y)
 template <class T = void> struct less {
     /// \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.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::less_impl>(x, y);
+        return boost::pfr::lt(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -163,19 +142,19 @@ template <class T = void> struct less {
 template <> struct less<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::less_impl>(x, y);
+        return boost::pfr::lt(x, y);
     }
 
     typedef std::true_type is_transparent;
 };
 /// @endcond
 
-/// \brief std::greater_equal like comparator
+/// \brief std::greater_equal like comparator that returns \forcedlink{ge}(x, y)
 template <class T = void> struct greater_equal {
     /// \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;
     /// or if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::greater_equal_impl>(x, y);
+        return boost::pfr::ge(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -192,19 +171,19 @@ template <class T = void> struct greater_equal {
 template <> struct greater_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::greater_equal_impl>(x, y);
+        return boost::pfr::ge(x, y);
     }
 
     typedef std::true_type is_transparent;
 };
 /// @endcond
 
-/// \brief std::less_equal like comparator
+/// \brief std::less_equal like comparator that returns \forcedlink{le}(x, y)
 template <class T = void> struct less_equal {
     /// \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;
     /// or if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::less_equal_impl>(x, y);
+        return boost::pfr::le(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -221,7 +200,7 @@ template <class T = void> struct less_equal {
 template <> struct less_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::less_equal_impl>(x, y);
+        return boost::pfr::le(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -229,28 +208,14 @@ template <> struct less_equal<void> {
 /// @endcond
 
 
-/// \brief std::hash like functor
+/// \brief std::hash like functor that returns \forcedlink{hash_value}(x)
 template <class T> struct hash {
     /// \return hash value of \b x.
     std::size_t operator()(const T& x) const {
-        constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
-#if BOOST_PFR_USE_CPP17
-        return detail::hash_impl<0, fields_count_val>::compute(detail::tie_as_tuple(x));
-#else
-        std::size_t result = 0;
-        ::boost::pfr::detail::for_each_field_dispatcher(
-            x,
-            [&result](const auto& lhs) {
-                result = detail::hash_impl<0, fields_count_val>::compute(lhs);
-            },
-            detail::make_index_sequence<fields_count_val>{}
-        );
-
-        return result;
-#endif
+        return boost::pfr::hash_value(x);
     }
 };
 
 }} // namespace boost::pfr
 
-#endif // BOOST_PFR_PRECISE_FUNCTORS_HPP
+#endif // BOOST_PFR_FUNCTORS_HPP

include/boost/pfr/io.hpp

@@ -0,0 +1,113 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_IO_HPP
+#define BOOST_PFR_IO_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/detectors.hpp>
+#include <boost/pfr/io_fields.hpp>
+
+/// \file boost/pfr/io.hpp
+/// Contains IO stream manipulator \forcedlink{io} for types.
+/// If type is streamable using its own operator or its conversion operator, then the types operator is used.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/io.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     std::cout << boost::pfr::io(s1);  // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+namespace detail {
+
+///////////////////// Helper typedefs
+    template <class Stream, class Type>
+    using enable_not_ostreamable_t = std::enable_if_t<
+        not_appliable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_not_istreamable_t = std::enable_if_t<
+        not_appliable<istreamable_detector, Stream&, Type&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_ostreamable_t = std::enable_if_t<
+        !not_appliable<ostreamable_detector, Stream&, const std::remove_reference_t<Type>&>::value,
+        Stream&
+    >;
+
+    template <class Stream, class Type>
+    using enable_istreamable_t = std::enable_if_t<
+        !not_appliable<istreamable_detector, Stream&, Type&>::value,
+        Stream&
+    >;
+
+///////////////////// IO impl
+
+template <class T>
+struct io_impl {
+    T value;
+};
+
+template <class Char, class Traits, class T>
+enable_not_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
+    return out << boost::pfr::io_fields(std::forward<T>(x.value));
+}
+
+template <class Char, class Traits, class T>
+enable_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, io_impl<T>&& x) {
+    return out << x.value;
+}
+
+template <class Char, class Traits, class T>
+enable_not_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
+    return in >> boost::pfr::io_fields(std::forward<T>(x.value));
+}
+
+template <class Char, class Traits, class T>
+enable_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, io_impl<T>&& x) {
+    return in >> x.value;
+}
+
+} // namespace detail
+
+/// IO manipulator to read/write \aggregate `value` using its IO stream operators or using \forcedlink{io_fields} if operators are not available.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i; short s; };
+///     my_struct x;
+///     std::stringstream ss;
+///     ss << "{ 12, 13 }";
+///     ss >> boost::pfr::io(x);
+///     assert(x.i == 12);
+///     assert(x.s == 13);
+/// \endcode
+///
+/// \customio
+template <class T>
+auto io(T&& value) noexcept {
+    return detail::io_impl<T>{std::forward<T>(value)};
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_IO_HPP

include/boost/pfr/io_fields.hpp

@@ -0,0 +1,164 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#ifndef BOOST_PFR_IO_FIELDS_HPP
+#define BOOST_PFR_IO_FIELDS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core.hpp>
+
+#include <type_traits>
+#include <utility>      // metaprogramming stuff
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/io.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/tuple_size.hpp>
+
+/// \file boost/pfr/io_fields.hpp
+/// Contains IO manipulator \forcedlink{io_fields} to read/write any \aggregate field-by-field.
+///
+/// \b Example:
+/// \code
+///     struct my_struct {
+///         int i;
+///         short s;
+///     };
+///
+///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
+///         return os << boost::pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
+///     }
+///
+///     std::istream& operator>>(std::istream& is, my_struct& x) {
+///         return is >> boost::pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
+///     }
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+namespace detail {
+
+template <class T>
+struct io_fields_impl {
+    T value;
+};
+
+
+template <class Char, class Traits, class T>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<const T&>&& x) {
+    const T& value = x.value;
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<T>();
+    out << '{';
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    detail::print_impl<0, fields_count_val>::print(out, detail::tie_as_tuple(value));
+#else
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [&out](const auto& val) {
+            // We can not reuse `fields_count_val` in lambda because compilers had issues with
+            // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+            constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<T>();
+            detail::print_impl<0, fields_count_val_lambda>::print(out, val);
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+#endif
+    return out << '}';
+}
+
+
+template <class Char, class Traits, class T>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, io_fields_impl<T>&& x) {
+    return out << io_fields_impl<const std::remove_reference_t<T>&>{x.value};
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T&>&& x) {
+    T& value = x.value;
+    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<T>();
+
+    const auto prev_exceptions = in.exceptions();
+    in.exceptions( typename std::basic_istream<Char, Traits>::iostate(0) );
+    const auto prev_flags = in.flags( typename std::basic_istream<Char, Traits>::fmtflags(0) );
+
+    char parenthis = {};
+    in >> parenthis;
+    if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
+
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    detail::read_impl<0, fields_count_val>::read(in, detail::tie_as_tuple(value));
+#else
+    ::boost::pfr::detail::for_each_field_dispatcher(
+        value,
+        [&in](const auto& val) {
+            // We can not reuse `fields_count_val` in lambda because compilers had issues with
+            // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+            constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<T>();
+            detail::read_impl<0, fields_count_val_lambda>::read(in, val);
+        },
+        detail::make_index_sequence<fields_count_val>{}
+    );
+#endif
+
+    in >> parenthis;
+    if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
+
+    in.flags(prev_flags);
+    in.exceptions(prev_exceptions);
+
+    return in;
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<const T&>&& ) {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a boost::pfr::io_fields wrapped type T with const qualifier.");
+    return in;
+}
+
+template <class Char, class Traits, class T>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, io_fields_impl<T>&& ) {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Attempt to use istream operator on a boost::pfr::io_fields wrapped temporary of type T.");
+    return in;
+}
+
+} // namespace detail
+
+/// IO manipulator to read/write \aggregate `value` field-by-field.
+///
+/// \b Example:
+/// \code
+///     struct my_struct {
+///         int i;
+///         short s;
+///     };
+///
+///     std::ostream& operator<<(std::ostream& os, const my_struct& x) {
+///         return os << boost::pfr::io_fields(x);  // Equivalent to: os << "{ " << x.i << " ," <<  x.s << " }"
+///     }
+///
+///     std::istream& operator>>(std::istream& is, my_struct& x) {
+///         return is >> boost::pfr::io_fields(x);  // Equivalent to: is >> "{ " >> x.i >> " ," >>  x.s >> " }"
+///     }
+/// \endcode
+///
+/// Input and output streaming operators for `boost::pfr::io_fields` are symmetric, meaning that you get the original value by streaming it and
+/// reading back if each fields streaming operator is symmetric.
+///
+/// \customio
+template <class T>
+auto io_fields(T&& value) noexcept {
+    return detail::io_fields_impl<T>{std::forward<T>(value)};
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_IO_FIELDS_HPP

include/boost/pfr/ops.hpp

@@ -0,0 +1,187 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_OPS_HPP
+#define BOOST_PFR_OPS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/detectors.hpp>
+#include <boost/pfr/ops_fields.hpp>
+
+/// \file boost/pfr/ops.hpp
+/// Contains comparison and hashing functions.
+/// If type is comparable using its own operator or its conversion operator, then the types operator is used. Otherwise
+/// the operation is done via corresponding function from boost/pfr/ops.hpp header.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/ops.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
+///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
+///     assert(boost::pfr::lt(s1, s2));
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+namespace detail {
+
+///////////////////// Helper typedefs that are used by all the ops
+    template <template <class, class> class Detector, class T, class U>
+    using enable_not_comp_base_t = std::enable_if_t<
+        not_appliable<Detector, T const&, U const&>::value,
+        bool
+    >;
+
+    template <template <class, class> class Detector, class T, class U>
+    using enable_comp_base_t = std::enable_if_t<
+        !not_appliable<Detector, T const&, U const&>::value,
+        bool
+    >;
+///////////////////// std::enable_if_t like functions that enable only if types do not support operation
+
+    template <class T, class U> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T, U>;
+
+    template <class T> using enable_not_hashable_t = std::enable_if_t<
+        not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
+///////////////////// std::enable_if_t like functions that enable only if types do support operation
+
+    template <class T, class U> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T, U>;
+
+    template <class T> using enable_hashable_t = std::enable_if_t<
+        !not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
+} // namespace detail
+
+
+/// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{eq_fields}(lhs, rhs).
+///
+/// \returns true if lhs is equal to rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::eq_fields(lhs, rhs);
+}
+
+/// \overload eq
+template <class T, class U>
+constexpr detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
+    return lhs == rhs;
+}
+
+
+/// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ne_fields}(lhs, rhs).
+///
+/// \returns true if lhs is not equal to rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::ne_fields(lhs, rhs);
+}
+
+/// \overload ne
+template <class T, class U>
+constexpr detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
+    return lhs != rhs;
+}
+
+
+/// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+///
+/// \returns true if lhs is less than rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::lt_fields(lhs, rhs);
+}
+
+/// \overload lt
+template <class T, class U>
+constexpr detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
+    return lhs < rhs;
+}
+
+
+/// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+///
+/// \returns true if lhs is greater than rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::gt_fields(lhs, rhs);
+}
+
+/// \overload gt
+template <class T, class U>
+constexpr detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
+    return lhs > rhs;
+}
+
+
+/// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{le_fields}(lhs, rhs).
+///
+/// \returns true if lhs is less or equal to rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_le_comp_t<T, U> le(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::le_fields(lhs, rhs);
+}
+
+/// \overload le
+template <class T, class U>
+constexpr detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
+    return lhs <= rhs;
+}
+
+
+/// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ge_fields}(lhs, rhs).
+///
+/// \returns true if lhs is greater or equal to rhs; false otherwise
+template <class T, class U>
+constexpr detail::enable_not_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) noexcept {
+    return boost::pfr::ge_fields(lhs, rhs);
+}
+
+/// \overload ge
+template <class T, class U>
+constexpr detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
+    return lhs >= rhs;
+}
+
+
+/// \brief Hashes value using its own std::hash specialization; if no std::hash specialization avalable returns \forcedlink{hash_fields}(value).
+///
+/// \returns std::size_t with hash of the value
+template <class T>
+constexpr detail::enable_not_hashable_t<T> hash_value(const T& value) noexcept {
+    return boost::pfr::hash_fields(value);
+}
+
+/// \overload hash_value
+template <class T>
+constexpr detail::enable_hashable_t<T> hash_value(const T& value) {
+    return std::hash<T>{}(value);
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_OPS_HPP

include/boost/pfr/ops_fields.hpp

@@ -0,0 +1,127 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_OPS_FIELDS_HPP
+#define BOOST_PFR_OPS_FIELDS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/core.hpp>
+#include <boost/pfr/detail/functional.hpp>
+
+/// \file boost/pfr/ops_fields.hpp
+/// Contains field-by-fields comparison and hash functions.
+///
+/// \b Example:
+/// \code
+///     #include <boost/pfr/ops_fields.hpp>
+///     struct comparable_struct {      // No operators defined for that structure
+///         int i; short s;
+///     };
+///     // ...
+///
+///     comparable_struct s1 {0, 1};
+///     comparable_struct s2 {0, 2};
+///     assert(boost::pfr::lt_fields(s1, s2));
+/// \endcode
+///
+/// \podops for other ways to define operators and more details.
+///
+/// \b Synopsis:
+namespace boost { namespace pfr {
+
+    /// Does a field-by-field equality comparison.
+    ///
+    /// \returns `L == R && tuple_size_v<T> == tuple_size_v<U>`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool eq_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field inequality comparison.
+    ///
+    /// \returns `L != R || tuple_size_v<T> != tuple_size_v<U>`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool ne_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::not_equal_impl>(lhs, rhs);
+    }
+
+    /// Does a field-by-field greter comparison.
+    ///
+    /// \returns `L > R || (L == R && tuple_size_v<T> > tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool gt_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::greater_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field less comparison.
+    ///
+    /// \returns `L < R || (L == R && tuple_size_v<T> < tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool lt_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::less_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field greater equal comparison.
+    ///
+    /// \returns `L > R || (L == R && tuple_size_v<T> >= tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool ge_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::greater_equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field less equal comparison.
+    ///
+    /// \returns `L < R || (L == R && tuple_size_v<T> <= tuple_size_v<U>)`, where `L` and
+    /// `R` are the results of calling `std::tie` on first `N` fields of `lhs` and
+    // `rhs` respectively; `N` is `std::min(tuple_size_v<T>, tuple_size_v<U>)`.
+    template <class T, class U>
+    constexpr bool le_fields(const T& lhs, const U& rhs) noexcept {
+        return detail::binary_visit<detail::less_equal_impl>(lhs, rhs);
+    }
+
+
+    /// Does a field-by-field hashing.
+    ///
+    /// \returns combined hash of all the fields
+    template <class T>
+    std::size_t hash_fields(const T& x) {
+        constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+        return detail::hash_impl<0, fields_count_val>::compute(detail::tie_as_tuple(x));
+#else
+        std::size_t result = 0;
+        ::boost::pfr::detail::for_each_field_dispatcher(
+            x,
+            [&result](const auto& lhs) {
+                // We can not reuse `fields_count_val` in lambda because compilers had issues with
+                // passing constexpr variables into lambdas. Computing is again is the most portable solution.
+                constexpr std::size_t fields_count_val_lambda = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
+                result = detail::hash_impl<0, fields_count_val_lambda>::compute(lhs);
+            },
+            detail::make_index_sequence<fields_count_val>{}
+        );
+
+        return result;
+#endif
+    }
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_OPS_HPP

include/boost/pfr/precise.hpp

@@ -1,19 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_PRECISE_HPP
-#define BOOST_PFR_PRECISE_HPP
-
-/// \file boost/pfr/precise.hpp
-/// Includes all the Boost.PFR headers that do not define `flat_*` functions, except \xmlonly<link linkend='header.boost.pfr.precise.global_ops_hpp'>boost/pfr/precise/global_ops.hpp</link>\endxmlonly
-
-#include <boost/pfr/precise/core.hpp>
-#include <boost/pfr/precise/functors.hpp>
-#include <boost/pfr/precise/ops.hpp>
-#include <boost/pfr/precise/io.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
-#include <boost/pfr/precise/functions_for.hpp>
-
-#endif // BOOST_PFR_PRECISE_HPP

include/boost/pfr/precise/core.hpp

@@ -1,177 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_PRECISE_CORE_HPP
-#define BOOST_PFR_PRECISE_CORE_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <type_traits>
-#include <utility>      // metaprogramming stuff
-
-#include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/stdtuple.hpp>
-#include <boost/pfr/detail/for_each_field_impl.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
-
-#include <boost/pfr/precise/tuple_size.hpp>
-#if BOOST_PFR_USE_CPP17
-#   include <boost/pfr/detail/core17.hpp>
-#else
-#   include <boost/pfr/detail/core14.hpp>
-#endif
-
-#include <boost/pfr/detail/tie_from_structure_tuple.hpp>
-
-namespace boost { namespace pfr {
-
-/// \brief Returns reference or const reference to a field with index `I` in aggregate T.
-///
-/// \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s {10, 11};
-///     assert(boost::pfr::get<0>(s) == 10);
-///     boost::pfr::get<1>(s) = 0;
-/// \endcode
-template <std::size_t I, class T>
-constexpr decltype(auto) get(const T& val) noexcept {
-    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
-}
-
-
-/// \overload get
-template <std::size_t I, class T>
-constexpr decltype(auto) get(T& val) noexcept {
-    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
-}
-
-
-/// \brief `tuple_element` has a `typedef type-of-a-field-with-index-I-in-aggregate-T type;`
-///
-/// \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
-///
-/// \b Example:
-/// \code
-///     std::vector<  boost::pfr::tuple_element<0, my_structure>::type  > v;
-/// \endcode
-template <std::size_t I, class T>
-using tuple_element = detail::sequence_tuple::tuple_element<I, decltype( ::boost::pfr::detail::tie_as_tuple(std::declval<T&>()) ) >;
-
-
-/// \brief Type of a field with index `I` in aggregate `T`.
-///
-/// \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
-///
-/// \b Example:
-/// \code
-///     std::vector<  boost::pfr::tuple_element_t<0, my_structure>  > v;
-/// \endcode
-template <std::size_t I, class T>
-using tuple_element_t = typename tuple_element<I, T>::type;
-
-
-/// \brief Creates an `std::tuple` from an aggregate T.
-///
-/// \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s {10, 11};
-///     std::tuple<int, short> t = make_tuple(s);
-///     assert(get<0>(t) == 10);
-/// \endcode
-template <class T>
-constexpr auto structure_to_tuple(const T& val) noexcept {
-    return detail::make_stdtuple_from_tietuple(
-        detail::tie_as_tuple(val),
-        detail::make_index_sequence< tuple_size_v<T> >()
-    );
-}
-
-
-/// \brief Creates an `std::tuple` with lvalue references to fields of an aggregate T.
-///
-/// \b Requires: C++17 or \flatpod{C++14 flat POD or C++14 with not disabled Loophole}.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s;
-///     structure_tie(s) = std::tuple<int, short>{10, 11};
-///     assert(s.s == 11);
-/// \endcode
-template <class T>
-constexpr auto structure_tie(T& val) noexcept {
-    return detail::make_stdtiedtuple_from_tietuple(
-        detail::tie_as_tuple(val),
-        detail::make_index_sequence< tuple_size_v<T> >()
-    );
-}
-
-/// Calls `func` for each field of a `value`.
-///
-/// \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
-///
-/// \param func must have one of the following signatures:
-///     * any_return_type func(U&& field)                // field of value is perfect forwarded to function
-///     * any_return_type func(U&& field, std::size_t i)
-///     * any_return_type func(U&& value, I i)  // Here I is an `std::integral_constant<size_t, field_index>`
-///
-/// \param value To each field of this variable will be the `func` applied.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     int sum = 0;
-///     for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
-///     assert(sum == 42);
-/// \endcode
-template <class T, class F>
-void for_each_field(T&& value, F&& func) {
-    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
-
-    ::boost::pfr::detail::for_each_field_dispatcher(
-        value,
-        [f = std::forward<F>(func)](auto&& t) mutable {
-            // MSVC related workaround. It's lambdas do not capture constexprs.
-            constexpr std::size_t fields_count_val_in_lambda
-                = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
-
-            ::boost::pfr::detail::for_each_field_impl(
-                t,
-                std::forward<F>(f),
-                detail::make_index_sequence<fields_count_val_in_lambda>{},
-                std::is_rvalue_reference<T&&>{}
-            );
-        },
-        detail::make_index_sequence<fields_count_val>{}
-    );
-}
-
-/// \brief Create a tuple of lvalue references capable of de-structuring
-/// assignment from fields of an aggregate T.
-///
-/// \b Example:
-/// \code
-///     auto f() {
-///       struct { struct { int x, y } p; short s; } res { { 4, 5 }, 6 };
-///       return res;
-///     }
-///     auto [p, s] = f();
-///     tie_from_structure(p, s) = f();
-/// \endcode
-template <typename... Elements>
-constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Elements&... args) noexcept {
-    return detail::tie_from_structure_tuple<Elements...>(args...);
-}
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_PRECISE_CORE_HPP

include/boost/pfr/precise/functions_for.hpp

@@ -1,79 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_PRECISE_FUNCTIONS_FOR_HPP
-#define BOOST_PFR_PRECISE_FUNCTIONS_FOR_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/precise/functors.hpp>
-#include <boost/pfr/precise/io.hpp>
-
-/// \def BOOST_PFR_PRECISE_FUNCTIONS_FOR(T)
-/// Defines comparison operators and stream operators for T.
-/// If type T is comparable or streamable using it's own operator (but not it's conversion operator), then the original operator is used.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/precise/functions_for.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     BOOST_PFR_PRECISE_FUNCTIONS_FOR(comparable_struct)
-///     // ...
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b Defines \b following \b for \b T:
-/// \code
-/// bool operator==(const T& lhs, const T& rhs);
-/// bool operator!=(const T& lhs, const T& rhs);
-/// bool operator< (const T& lhs, const T& rhs);
-/// bool operator> (const T& lhs, const T& rhs);
-/// bool operator<=(const T& lhs, const T& rhs);
-/// bool operator>=(const T& lhs, const T& rhs);
-///
-/// template <class Char, class Traits>
-/// std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-///
-/// template <class Char, class Traits>
-/// std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-///
-/// // helper function for Boost unordered containers and boost::hash<>.
-/// std::size_t hash_value(const T& value);
-/// \endcode
-
-#define BOOST_PFR_PRECISE_FUNCTIONS_FOR(T)                                                                              \
-    static inline bool operator==(const T& lhs, const T& rhs) { return ::boost::pfr::equal_to<T>{}(lhs, rhs);      }    \
-    static inline bool operator!=(const T& lhs, const T& rhs) { return ::boost::pfr::not_equal<T>{}(lhs, rhs);     }    \
-    static inline bool operator< (const T& lhs, const T& rhs) { return ::boost::pfr::less<T>{}(lhs, rhs);          }    \
-    static inline bool operator> (const T& lhs, const T& rhs) { return ::boost::pfr::greater<T>{}(lhs, rhs);       }    \
-    static inline bool operator<=(const T& lhs, const T& rhs) { return ::boost::pfr::less_equal<T>{}(lhs, rhs);    }    \
-    static inline bool operator>=(const T& lhs, const T& rhs) { return ::boost::pfr::greater_equal<T>{}(lhs, rhs); }    \
-    template <class Char, class Traits>                                                                                 \
-    static ::std::basic_ostream<Char, Traits>& operator<<(::std::basic_ostream<Char, Traits>& out, const T& value) {    \
-        ::boost::pfr::write(out, value);                                                                                \
-        return out;                                                                                                     \
-    }                                                                                                                   \
-    template <class Char, class Traits>                                                                                 \
-    static ::std::basic_istream<Char, Traits>& operator>>(::std::basic_istream<Char, Traits>& in, T& value) {           \
-        ::boost::pfr::read(in, value);                                                                                  \
-        return in;                                                                                                      \
-    }                                                                                                                   \
-    static inline std::size_t hash_value(const T& v) {                                                                  \
-        return ::boost::pfr::hash<T>{}(v);                                                                              \
-    }                                                                                                                   \
-/**/
-
-#endif // BOOST_PFR_PRECISE_FUNCTIONS_FOR_HPP
-
-

include/boost/pfr/precise/global_ops.hpp

@@ -1,114 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_PRECISE_GLOBAL_OPS_HPP
-#define BOOST_PFR_PRECISE_GLOBAL_OPS_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/precise/functors.hpp>
-#include <boost/pfr/precise/core.hpp>
-#include <boost/pfr/precise/io.hpp>
-
-/// \file boost/pfr/precise/global_ops.hpp
-/// Contains comparison operators and stream operators for any types that do not have their own operators.
-/// If type is comparable or streamable using it's own operator (but not it's conversion operator), then the original operator is used.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/precise/global_ops.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     // ...
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b This \b header \b defines:
-/// @cond
-namespace boost { namespace pfr { namespace detail {
-
-    template <class T, class U>
-    using enable_comparisons = std::enable_if_t<
-        std::is_same<T, U>::value,
-        bool
-    >;
-
-}}} // namespace boost::pfr::detail
-/// @endcond
-
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    template <class T> bool operator==(const T& lhs, const T& rhs);
-    template <class T> bool operator!=(const T& lhs, const T& rhs);
-    template <class T> bool operator< (const T& lhs, const T& rhs);
-    template <class T> bool operator> (const T& lhs, const T& rhs);
-    template <class T> bool operator<=(const T& lhs, const T& rhs);
-    template <class T> bool operator>=(const T& lhs, const T& rhs);
-
-    template <class Char, class Traits, class T>
-    std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-
-    template <class Char, class Traits, class T>
-    std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-
-    /// \brief helper function for Boost unordered containers and boost::hash<>.
-    template <class T> std::size_t hash_value(const T& value);
-#else
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator==(const T& lhs, const U& rhs) {
-        return ::boost::pfr::equal_to<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator!=(const T& lhs, const U& rhs) {
-        return ::boost::pfr::not_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator<(const T& lhs, const U& rhs) {
-        return ::boost::pfr::less<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator>(const T& lhs, const U& rhs) {
-        return ::boost::pfr::greater<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator<=(const T& lhs, const U& rhs) {
-        return ::boost::pfr::less_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T, class U>
-    static boost::pfr::detail::enable_comparisons<T, U> operator>=(const T& lhs, const U& rhs) {
-        return ::boost::pfr::greater_equal<T>{}(lhs, rhs);
-    }
-
-    template <class Char, class Traits, class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::basic_ostream<Char, Traits>&> operator<<(std::basic_ostream<Char, Traits>& out, const T& value) {
-        ::boost::pfr::write(out, value);
-        return out;
-    }
-
-    template <class Char, class Traits, class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::basic_istream<Char, Traits>&> operator>>(std::basic_istream<Char, Traits>& in, T& value) {
-        ::boost::pfr::read(in, value);
-        return in;
-    }
-
-    template <class T>
-    static std::size_t hash_value(const T& value) {
-        return ::boost::pfr::hash<T>{}(value);
-    }
-#endif
-
-#endif // BOOST_PFR_PRECISE_GLOBAL_OPS_HPP

include/boost/pfr/precise/io.hpp

@@ -1,104 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-#ifndef BOOST_PFR_PRECISE_IO_HPP
-#define BOOST_PFR_PRECISE_IO_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <type_traits>
-#include <utility>      // metaprogramming stuff
-
-#include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/io.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
-
-#if BOOST_PFR_USE_CPP17
-#   include <boost/pfr/detail/core17.hpp>
-#else
-#   include <boost/pfr/detail/core14.hpp>
-#endif
-
-namespace boost { namespace pfr {
-
-/// \brief Writes aggregate `value` to `out`
-///
-/// \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s{12, 13};
-///     write(std::cout, s); // outputs '{12, 13}'
-/// \endcode
-template <class Char, class Traits, class T>
-void write(std::basic_ostream<Char, Traits>& out, const T& value) {
-    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
-    out << '{';
-#if BOOST_PFR_USE_CPP17
-    detail::print_impl<0, fields_count_val>::print(out, detail::tie_as_tuple(value));
-#else
-    ::boost::pfr::detail::for_each_field_dispatcher(
-        value,
-        [&out](const auto& val) {
-            detail::print_impl<0, fields_count_val>::print(out, val);
-        },
-        detail::make_index_sequence<fields_count_val>{}
-    );
-#endif
-    out << '}';
-}
-
-/// Reads aggregate `value` from stream `in`
-///
-/// \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
-///
-/// \b Example:
-/// \code
-///     struct my_struct { int i, short s; };
-///     my_struct s;
-///     std::stringstream ss;
-///     ss << "{ 12, 13 }";
-///     ss >> s;
-///     assert(s.i == 12);
-///     assert(s.i == 13);
-/// \endcode
-template <class Char, class Traits, class T>
-void read(std::basic_istream<Char, Traits>& in, T& value) {
-    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();
-
-    const auto prev_exceptions = in.exceptions();
-    in.exceptions( typename std::basic_istream<Char, Traits>::iostate(0) );
-    const auto prev_flags = in.flags( typename std::basic_istream<Char, Traits>::fmtflags(0) );
-
-    char parenthis = {};
-    in >> parenthis;
-    if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
-
-#if BOOST_PFR_USE_CPP17
-    detail::read_impl<0, fields_count_val>::read(in, detail::tie_as_tuple(value));
-#else
-    ::boost::pfr::detail::for_each_field_dispatcher(
-        value,
-        [&in](const auto& val) {
-            detail::read_impl<0, fields_count_val>::read(in, val);
-        },
-        detail::make_index_sequence<fields_count_val>{}
-    );
-#endif
-
-    in >> parenthis;
-    if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
-
-    in.flags(prev_flags);
-    in.exceptions(prev_exceptions);
-}
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_PRECISE_IO_HPP

include/boost/pfr/precise/ops.hpp

@@ -1,147 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PFR_PRECISE_OPS_HPP
-#define BOOST_PFR_PRECISE_OPS_HPP
-#pragma once
-
-#include <boost/pfr/detail/config.hpp>
-
-#include <boost/pfr/detail/detectors.hpp>
-#include <boost/pfr/precise/functors.hpp>
-#include <boost/pfr/precise/core.hpp>
-#include <boost/pfr/precise/io.hpp>
-
-/// \file boost/pfr/precise/ops.hpp
-/// Contains comparison operators and stream operators for types that do not have their own operators.
-/// If type is comparable or streamable using it's own operator or it's conversion operator, then the original operator is used.
-///
-/// Just write \b using \b namespace \b ops; and operators will be available in scope.
-///
-/// \b Requires: C++17 or \constexprinit{C++14 constexpr aggregate intializable type}.
-///
-/// \b Example:
-/// \code
-///     #include <boost/pfr/precise/ops.hpp>
-///     struct comparable_struct {      // No operators defined for that structure
-///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
-///     };
-///     // ...
-///
-///     using namespace ops;
-///
-///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
-///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
-///     assert(s1 < s2);
-///     std::cout << s1 << std::endl; // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
-/// \endcode
-///
-/// \podops for other ways to define operators and more details.
-///
-/// \b This \b header \b contains:
-namespace boost { namespace pfr {
-
-namespace detail {
-
-///////////////////// Helper typedef that it used by all the enable_not_*_comp_t
-    template <template <class, class> class Detector, class T>
-    using enable_not_comp_base_t = typename std::enable_if<
-        not_appliable<Detector, T const&, T const&>::value,
-        bool
-    >::type;
-
-///////////////////// std::enable_if_t like functions that enable only if types do not support operation and are PODs
-
-    template <class T> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T>;
-    template <class T> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T>;
-    template <class T> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T>;
-    template <class T> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T>;
-    template <class T> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T>;
-    template <class T> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T>;
-
-    template <class Stream, class Type>
-    using enable_not_ostreamable_t = typename std::enable_if<
-        not_appliable<ostreamable_detector, Stream&, Type const&>::value,
-        Stream&
-    >::type;
-
-    template <class Stream, class Type>
-    using enable_not_istreamable_t = typename std::enable_if<
-        not_appliable<istreamable_detector, Stream&, Type&>::value,
-        Stream&
-    >::type;
-} // namespace detail
-
-namespace ops {
-#ifdef BOOST_PFR_DOXYGEN_INVOKED
-    template <class T> bool operator==(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator!=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator< (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator> (const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator<=(const T& lhs, const T& rhs) noexcept;
-    template <class T> bool operator>=(const T& lhs, const T& rhs) noexcept;
-
-    template <class Char, class Traits, class T>
-    std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& out, const T& value);
-
-    template <class Char, class Traits, class T>
-    std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& in, T& value);
-
-    /// \brief helper function for Boost
-    template <class T> std::size_t hash_value(const T& value) noexcept;
-#else
-    template <class T>
-    static detail::enable_not_eq_comp_t<T> operator==(const T& lhs, const T& rhs) noexcept {
-        return equal_to<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_not_ne_comp_t<T> operator!=(const T& lhs, const T& rhs) noexcept {
-        return not_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_not_lt_comp_t<T> operator<(const T& lhs, const T& rhs) noexcept {
-        return less<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_not_gt_comp_t<T> operator>(const T& lhs, const T& rhs) noexcept {
-        return greater<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_not_le_comp_t<T> operator<=(const T& lhs, const T& rhs) noexcept {
-        return less_equal<T>{}(lhs, rhs);
-    }
-
-    template <class T>
-    static detail::enable_not_ge_comp_t<T> operator>=(const T& lhs, const T& rhs) noexcept {
-        return greater_equal<T>{}(lhs, rhs);
-    }
-
-    template <class Char, class Traits, class T>
-    static detail::enable_not_ostreamable_t<std::basic_ostream<Char, Traits>, T> operator<<(std::basic_ostream<Char, Traits>& out, const T& value) {
-        boost::pfr::write(out, value);
-        return out;
-    }
-
-    template <class Char, class Traits, class T>
-    static detail::enable_not_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_istream<Char, Traits>& in, T& value) {
-        boost::pfr::read(in, value);
-        return in;
-    }
-
-    template <class T>
-    static std::enable_if_t<std::is_pod<T>::value, std::size_t> hash_value(const T& value) noexcept {
-        return hash<T>{}(value);
-    }
-
-#endif
-} // namespace ops
-
-}} // namespace boost::pfr
-
-#endif // BOOST_PFR_PRECISE_OPS_HPP

include/boost/pfr/traits.hpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_TRAITS_HPP
+#define BOOST_PFR_TRAITS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/possible_reflectable.hpp>
+#include <type_traits>
+
+/// \file boost/pfr/traits.hpp
+/// Contains traits \forcedlink{is_reflectable} and \forcedlink{is_implicitly_reflectable} for detecting an ability to reflect type.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+/// 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.
+/// Every user may (and in some difficult cases - should) specialize is_reflectable on his own.
+///
+/// \b Example:
+/// \code
+///     namespace boost { namespace pfr {
+///         template<class All> struct is_reflectable<A, All> : std::false_type {};       // 'A' won't be interpreted as reflectable everywhere
+///         template<> struct is_reflectable<B, boost_fusion_tag> : std::false_type {};   // 'B' won't be interpreted as reflectable in only Boost Fusion
+///     }}
+/// \endcode
+/// \note is_reflectable affects is_implicitly_reflectable, the decision made by is_reflectable is used by is_implicitly_reflectable.
+template<class T, class WhatFor>
+struct is_reflectable { /*  does not have 'value' because value is unknown */ };
+
+// these specs can't be inherited from 'std::integral_constant< bool, boost::pfr::is_reflectable<T, WhatFor>::value >',
+// because it will break the sfinae-friendliness
+template<class T, class WhatFor>
+struct is_reflectable<const T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+template<class T, class WhatFor>
+struct is_reflectable<volatile T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+template<class T, class WhatFor>
+struct is_reflectable<const volatile T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+/// Checks the input type for the potential to be reflected.
+/// Specialize is_reflectable if you disagree with is_implicitly_reflectable's default decision.
+template<class T, class WhatFor>
+using is_implicitly_reflectable = std::integral_constant< bool, boost::pfr::detail::possible_reflectable<T, WhatFor>(1L) >;
+
+/// Checks the input type for the potential to be reflected.
+/// Specialize is_reflectable if you disagree with is_implicitly_reflectable_v's default decision.
+template<class T, class WhatFor>
+constexpr bool is_implicitly_reflectable_v = is_implicitly_reflectable<T, WhatFor>::value;
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_TRAITS_HPP
+

include/boost/pfr/traits_fwd.hpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+#define BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+namespace boost { namespace pfr {
+
+template<class T, class WhatFor>
+struct is_reflectable;
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+
+

include/boost/pfr/tuple_size.hpp

@@ -1,11 +1,11 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 
-#ifndef BOOST_PFR_PRECISE_TUPLE_SIZE_HPP
-#define BOOST_PFR_PRECISE_TUPLE_SIZE_HPP
+#ifndef BOOST_PFR_TUPLE_SIZE_HPP
+#define BOOST_PFR_TUPLE_SIZE_HPP
 #pragma once
 
 #include <boost/pfr/detail/config.hpp>
@@ -16,13 +16,14 @@
 #include <boost/pfr/detail/sequence_tuple.hpp>
 #include <boost/pfr/detail/fields_count.hpp>
 
+/// \file boost/pfr/tuple_size.hpp
+/// Contains tuple-like interfaces to get fields count \forcedlink{tuple_size}, \forcedlink{tuple_size_v}.
+///
+/// \b Synopsis:
 namespace boost { namespace pfr {
 
 /// Has a static const member variable `value` that contains fields count in a T.
-/// Works for any T that supports aggregate initialization even if T is not POD.
-/// \flattening{Flattens} only multidimensional arrays.
-///
-/// \b Requires: C++14.
+/// Works for any T that satisfies \aggregate.
 ///
 /// \b Example:
 /// \code
@@ -33,10 +34,7 @@ using tuple_size = detail::size_t_< boost::pfr::detail::fields_count<T>() >;
 
 
 /// `tuple_size_v` is a template variable that contains fields count in a T and
-/// works for any T that supports aggregate initialization even if T is not POD.
-/// \flattening{Flattens} only multidimensional arrays.
-///
-/// \b Requires: C++14.
+/// works for any T that satisfies \aggregate.
 ///
 /// \b Example:
 /// \code
@@ -47,4 +45,4 @@ constexpr std::size_t tuple_size_v = tuple_size<T>::value;
 
 }} // namespace boost::pfr
 
-#endif // BOOST_PFR_PRECISE_TUPLE_SIZE_HPP
+#endif // BOOST_PFR_TUPLE_SIZE_HPP

index.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<!--
+ Copyright (c) 2014-2023 Antony Polukhin
+ antoshkka at gmail dot com
+
+ Distributed under the Boost Software License,
+ Version 1.0. (See accompanying file LICENSE_1_0.txt
+ or copy at http://boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="0; url=https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html">
+<title>Boost.Stacktrace</title>
+<style>
+  body {
+    background: #fff;
+    color: #000;
+  }
+  a {
+    color: #00f;
+    text-decoration: none;
+  }
+</style>
+</head>
+<body>
+  <p>
+    Automatic redirection failed, please go to
+    <a href="https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html">https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html</a>
+  </p>
+  <p>
+    &copy; 2014-2023 Antony Polukhin
+  </p>
+</body>
+</html>

meta/libraries.json

@@ -0,0 +1,17 @@
+{
+    "key": "pfr",
+    "name": "PFR",
+    "authors": [
+        "Antony Polukhin"
+    ],
+    "maintainers": [
+        "Antony Polukhin <antoshkka -at- gmail.com>"
+    ],
+    "description": "Basic reflection  for user defined types.",
+    "category": [
+        "Data",
+        "Metaprogramming"
+    ],
+    "std": [ "proposal" ],
+    "cxxstd": "14"
+}

misc/generate_cpp17.py

@@ -1,6 +1,7 @@
 #!/usr/bin/python
 
-# Copyright (c) 2016-2020 Antony Polukhin
+# Copyright (c) 2016-2023 Antony Polukhin
+# Copyright (c) 2023 Denis Mikhailov
 #
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,8 +13,10 @@ import string
 
 # Skipping some letters that may produce keywords or are hard to read, or shadow template parameters
 ascii_letters = string.ascii_letters.replace("o", "").replace("O", "").replace("i", "").replace("I", "").replace("T", "")
+WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE = 3
 
-PROLOGUE = """// Copyright (c) 2016-2020 Antony Polukhin
+PROLOGUE = """// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2023 Denis Mikhailov
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -29,13 +32,13 @@ PROLOGUE = """// Copyright (c) 2016-2020 Antony Polukhin
 #pragma once
 
 #include <boost/pfr/detail/config.hpp>
-
 #if !BOOST_PFR_USE_CPP17
 #   error C++17 is required for this header.
 #endif
 
 #include <boost/pfr/detail/sequence_tuple.hpp>
-#include <boost/pfr/detail/fields_count.hpp>
+#include <boost/pfr/detail/size_t_.hpp>
+#include <type_traits> // for std::conditional_t, std::is_reference
 
 namespace boost { namespace pfr { namespace detail {
 
@@ -44,20 +47,43 @@ constexpr auto make_tuple_of_references(Args&&... args) noexcept {
   return sequence_tuple::tuple<Args&...>{ args... };
 }
 
+template<typename T, typename Arg>
+constexpr decltype(auto) add_cv_like(Arg& arg) noexcept {
+    if constexpr (std::is_const<T>::value && std::is_volatile<T>::value) {
+        return const_cast<const volatile Arg&>(arg);
+    }
+    else if constexpr (std::is_const<T>::value) {
+        return const_cast<const Arg&>(arg);
+    }
+    else if constexpr (std::is_volatile<T>::value) {
+        return const_cast<volatile Arg&>(arg);
+    }
+    else {
+        return const_cast<Arg&>(arg);
+    }
+}
+
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78939
+template<typename T, typename Sb, typename Arg>
+constexpr decltype(auto) workaround_cast(Arg& arg) noexcept {
+    using output_arg_t = std::conditional_t<!std::is_reference<Sb>(), decltype(detail::add_cv_like<T>(arg)), Sb>;
+    return const_cast<output_arg_t>(arg);
+}
+
 template <class T>
 constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
   return sequence_tuple::tuple<>{};
 }
 
 template <class T>
-constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
-  auto& [a] = val;
-  return ::boost::pfr::detail::make_tuple_of_references(a);
+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 {
+  auto& [a] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(detail::workaround_cast<T, decltype(a)>(a));
 }
 
 
 template <class T>
-constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
+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 {
   return ::boost::pfr::detail::make_tuple_of_references( val );
 }
 
@@ -65,16 +91,10 @@ constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class<
 
 ############################################################################################################################
 EPILOGUE = """
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-constexpr auto tie_as_tuple(T& val) noexcept {
-  static_assert(
-    !std::is_union<T>::value,
-    "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
-  );
-  typedef size_t_<fields_count<T>()> fields_count_tag;
-  return boost::pfr::detail::tie_as_tuple(val, fields_count_tag{});
+template <class T, std::size_t I>
+constexpr void tie_as_tuple(T& /*val*/, size_t_<I>) noexcept {
+  static_assert(sizeof(T) && false,
+                "====================> Boost.PFR: Too many fields in a structure T. Regenerate include/boost/pfr/detail/core17_generated.hpp file for appropriate count of fields. For example: `python ./misc/generate_cpp17.py 300 > include/boost/pfr/detail/core17_generated.hpp`");
 }
 
 }}} // namespace boost::pfr::detail
@@ -83,52 +103,71 @@ constexpr auto tie_as_tuple(T& val) noexcept {
 """
 
 ############################################################################################################################
-generate_sfinae_attempts = False
 
+def fold_workaround_cast(indexes, divider):
+    WORKAROUND_CAST_TEMPLATE = """
+detail::workaround_cast<T, decltype({arg})>({arg})
+"""
+    lines = []
+    div = ''
+    tokens = [x.strip() for x in indexes.split(',')]
+    casts = [WORKAROUND_CAST_TEMPLATE.strip().format(arg=tok)
+             for tok in tokens]
+    for i in range(0, len(casts)):
+        if i%WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE==0:
+            div = ''
+            lines.append('')
+        lines[-1] += div + casts[i]
+        div = ','
+    return divider.join(lines)
 
-if generate_sfinae_attempts:
-    print """
-    template <class T, std::size_t I>
-    constexpr auto tie_as_tuple(T& val, size_t_<I>) noexcept {
-      return tie_as_tuple(val, size_t_<I - 1>{});
-    }
-    """
+def calc_indexes_count(indexes):
+    tokens = [x.strip() for x in indexes.split(',')]
+    return len(tokens)
 
+class EmptyLinePrinter:
+    def print_once(self):
+        if not self.printed:
+            print("")
+            self.printed = True
+    printed = False
 
 indexes = "    a"
-print PROLOGUE
+print(PROLOGUE)
 funcs_count = 100 if len(sys.argv) == 1 else int(sys.argv[1])
 max_args_on_a_line = len(ascii_letters)
-for i in xrange(1, funcs_count):
+for i in range(1, funcs_count):
     if i % max_args_on_a_line == 0:
         indexes += ",\n    "
     else:
         indexes += ","
 
     if i >= max_args_on_a_line:
-        indexes += ascii_letters[i / max_args_on_a_line - 1] 
+        indexes += ascii_letters[i // max_args_on_a_line - 1]
     indexes += ascii_letters[i % max_args_on_a_line]
 
-    print "template <class T>"
-    print "constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + ">) noexcept {"
+    printed_casts = fold_workaround_cast(indexes.strip(), ",\n    ")
+    indexes_count = calc_indexes_count(indexes.strip())
+    empty_printer = EmptyLinePrinter()
+
+    print("template <class T>")
+    print("constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + ">) noexcept {")
     if i < max_args_on_a_line:
-        print "  auto& [" + indexes.strip() + "] = val;"
-        print "  return ::boost::pfr::detail::make_tuple_of_references(" + indexes.strip() + ");"
+        print("  auto& [" + indexes.strip() + "] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
     else:
-        print "  auto& ["
-        print indexes
-        print "  ] = val;"
-        print ""
-        print "  return ::boost::pfr::detail::make_tuple_of_references("
-        print indexes
-        print "  );"
+        print("  auto& [")
+        print(indexes)
+        print("  ] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
+        empty_printer.print_once()
+ 
+    if indexes_count < WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE:
+        print("  return ::boost::pfr::detail::make_tuple_of_references(" + printed_casts + ");")
+    else:
+        empty_printer.print_once()
+        print("  return ::boost::pfr::detail::make_tuple_of_references(")
+        print("    " + printed_casts)
+        print("  );")
 
-    print "}\n"
+    print("}\n")
 
-    if generate_sfinae_attempts:
-        print "template <class T>"
-        print "constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + "> v) noexcept"
-        print "  ->decltype( ::boost::pfr::detail::tie_as_tuple0(std::forward<T>(val), v) )"
-        print "{ return ::boost::pfr::detail::tie_as_tuple0(std::forward<T>(val), v); }\n"
-
-print EPILOGUE
+print(EPILOGUE)

misc/strip_boost_namespace.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+# Copyright (c) 2021 Antony Polukhin
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+echo "***** Making target path"
+TARGET_PATH="`dirname \"$0\"`/../../pfr_non_boost"
+rm -rf ${TARGET_PATH}/*
+mkdir -p ${TARGET_PATH}
+TARGET_PATH=`cd "${TARGET_PATH}";pwd`
+
+SOURCE_PATH="`dirname \"$0\"`/.."
+SOURCE_PATH=`cd "${SOURCE_PATH}";pwd`
+
+echo "***** Copying from ${SOURCE_PATH} to ${TARGET_PATH}"
+cp -rf ${SOURCE_PATH}/* ${TARGET_PATH}
+
+mv ${TARGET_PATH}/include/boost/* ${TARGET_PATH}/include/
+rm -rf ${TARGET_PATH}/include/boost
+rm -rf ${TARGET_PATH}/test
+rm ${TARGET_PATH}/misc/strip_boost_namespace.sh
+rm -rf ${TARGET_PATH}/meta
+
+echo "***** Changing sources"
+find ${TARGET_PATH} -type f | xargs sed -i 's|namespace boost { ||g'
+find ${TARGET_PATH} -type f | xargs sed -i 's|namespace boost {||g'
+find ${TARGET_PATH} -type f | xargs sed -i 's|} // namespace boost::| // namespace |g'
+
+find ${TARGET_PATH} -type f | xargs sed -i 's/::boost::pfr/::pfr/g'
+find ${TARGET_PATH} -type f | xargs sed -i 's/boost::pfr/pfr/g'
+find ${TARGET_PATH} -type f | xargs sed -i 's/BOOST_PFR_/PFR_/g'
+find ${TARGET_PATH} -type f | xargs sed -i 's|boost/pfr|pfr|g'
+
+find ${TARGET_PATH}/doc -type f | xargs sed -i 's|boost.pfr.|pfr.|g'
+find ${TARGET_PATH}/doc -type f | xargs sed -i 's|Boost.PFR|PFR|g'
+
+sed -i  's|# \[Boost.PFR\](https://boost.org/libs/pfr)|# [PFR](https://apolukhin.github.io/pfr_non_boost/)|g' ${TARGET_PATH}/README.md
+
+echo -n "***** Testing: "
+if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=1 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+    echo -n "OK"
+else
+    echo -n "FAIL"
+    exit 2
+fi
+if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=1 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+    echo -n ", OK"
+else
+    echo -n ", FAIL"
+    exit 3
+fi
+
+if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/get.cpp && ./a.out > /dev/null; then
+    echo -e ", OK"
+else
+    echo -e ", FAIL"
+    exit 4
+fi
+
+rm a.out || :
+
+echo "***** Done"

test/Jamfile

@@ -0,0 +1,9 @@
+#  Copyright (C) 2023 Denis Mikhailov
+#
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+build-project config ;
+build-project core ;

test/Jamfile.v2

@@ -1,193 +0,0 @@
-#  Copyright (C) 2016-2019, Antony Polukhin.
-#
-# Use, modification and distribution is subject to the Boost Software License,
-# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-#
-
-import testing ;
-import ../../config/checks/config : requires ;
-
-project
-    : source-location .
-    : requirements
-        <toolset>msvc:<cxxflags>"/std:c++latest"
-        <toolset>msvc:<define>BOOST_PFR_USE_CPP17=1
-        <define>BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING=1
-        [ requires cxx14_constexpr ]
-    ;
-
-local DISABLE_ON_MSVC = <toolset>msvc:<build>no ;
-local DISABLE_ON_CLANG8_PLUS = <toolset>clang-8:<build>no <toolset>clang-9:<build>no <toolset>clang-10:<build>no ;
-local LOOPHOLE_FLAT_DEF = <define>BOOST_PFR_TEST_FLAT <define>BOOST_PFR_USE_LOOPHOLE=1 $(DISABLE_ON_MSVC) $(DISABLE_ON_CLANG8_PLUS) ;
-local CLASSIC_FLAT_DEF = <define>BOOST_PFR_TEST_FLAT <define>BOOST_PFR_USE_LOOPHOLE=0 $(DISABLE_ON_MSVC) ;
-local LOOPHOLE_PREC_DEF = <define>BOOST_PFR_TEST_PRECISE <define>BOOST_PFR_USE_LOOPHOLE=1 $(DISABLE_ON_MSVC) $(DISABLE_ON_CLANG8_PLUS) ;
-local CLASSIC_PREC_DEF = <define>BOOST_PFR_TEST_PRECISE <define>BOOST_PFR_USE_LOOPHOLE=0 ;
-
-test-suite pfr
-  :
-    ##### Common tests
-    [ run common/offset_based_getter.cpp ]
-
-    [ run common/ops.cpp                : : : $(CLASSIC_FLAT_DEF)               : flat_ops ]
-    [ run common/ops.cpp                : : : $(LOOPHOLE_FLAT_DEF)              : flat_lh_ops ]
-    [ run common/ops.cpp                : : : $(CLASSIC_PREC_DEF)               : precise_ops ]
-    [ run common/ops.cpp                : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_ops ]
-
-    [ run common/global_ops.cpp         : : : $(CLASSIC_FLAT_DEF)               : flat_global_ops ]
-    [ run common/global_ops.cpp         : : : $(LOOPHOLE_FLAT_DEF)              : flat_lh_global_ops ]
-    [ run common/global_ops.cpp         : : : $(CLASSIC_PREC_DEF)               : precise_global_ops ]
-    [ run common/global_ops.cpp         : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_global_ops ]
-
-    [ run common/functions_for.cpp      : : : $(CLASSIC_FLAT_DEF)               : flat_function_for ]
-    [ run common/functions_for.cpp      : : : $(LOOPHOLE_FLAT_DEF)              : flat_lh_function_for ]
-    [ run common/functions_for.cpp      : : : $(CLASSIC_PREC_DEF)               : precise_function_for ]
-    [ run common/functions_for.cpp      : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_function_for ]
-
-    [ run common/read_write.cpp         : : : $(CLASSIC_FLAT_DEF)               : flat_read_write ]
-    [ run common/read_write.cpp         : : : $(LOOPHOLE_FLAT_DEF)              : flat_lh_read_write ]
-    [ run common/read_write.cpp         : : : $(CLASSIC_PREC_DEF)               : precise_read_write ]
-    [ run common/read_write.cpp         : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_read_write ]
-
-    [ run common/std_interactions.cpp   : : : $(CLASSIC_FLAT_DEF)               : flat_std_interactions ]
-    [ run common/std_interactions.cpp   : : : $(LOOPHOLE_FLAT_DEF)              : flat_lh_std_interactions ]
-    [ run common/std_interactions.cpp   : : : $(CLASSIC_PREC_DEF)               : precise_std_interactions ]
-    [ run common/std_interactions.cpp   : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_std_interactions ]
-
-    [ compile-fail common/movable_and_lvalue_references.cpp : $(CLASSIC_FLAT_DEF)   : flat_movable_and_lvalue_references ]
-    [ compile-fail common/movable_and_lvalue_references.cpp : $(LOOPHOLE_FLAT_DEF)  : flat_lh_movable_and_lvalue_references ]
-    [ compile-fail common/movable_and_lvalue_references.cpp : $(CLASSIC_PREC_DEF)   : precise_movable_and_lvalue_references ]
-    [ compile-fail common/movable_and_lvalue_references.cpp : $(LOOPHOLE_PREC_DEF)  : precise_lh_movable_and_lvalue_references ]
-
-    [ compile-fail common/private_fields.cpp : $(CLASSIC_FLAT_DEF)              : flat_private_fields ]
-    [ compile-fail common/private_fields.cpp : $(LOOPHOLE_FLAT_DEF)             : flat_lh_private_fields ]
-    [ compile-fail common/private_fields.cpp : $(CLASSIC_PREC_DEF)              : precise_private_fields ]
-    [ compile-fail common/private_fields.cpp : $(LOOPHOLE_PREC_DEF)             : precise_lh_private_fields ]
-
-    [ compile-fail common/protected_fields.cpp : $(CLASSIC_FLAT_DEF)            : flat_protected_fields ]
-    [ compile-fail common/protected_fields.cpp : $(LOOPHOLE_FLAT_DEF)           : flat_lh_protected_fields ]
-    [ compile-fail common/protected_fields.cpp : $(CLASSIC_PREC_DEF)            : precise_protected_fields ]
-    [ compile-fail common/protected_fields.cpp : $(LOOPHOLE_PREC_DEF)           : precise_lh_protected_fields ]
-
-    [ compile-fail common/virtual_functions.cpp : $(CLASSIC_FLAT_DEF)           : flat_virtual_functions ]
-    [ compile-fail common/virtual_functions.cpp : $(LOOPHOLE_FLAT_DEF)          : flat_lh_virtual_functions ]
-    [ compile-fail common/virtual_functions.cpp : $(CLASSIC_PREC_DEF)           : precise_virtual_functions ]
-    [ compile-fail common/virtual_functions.cpp : $(LOOPHOLE_PREC_DEF)          : precise_lh_virtual_functions ]
-
-    [ compile-fail common/ops_on_union.cpp : $(CLASSIC_FLAT_DEF)                : flat_on_union ]
-    [ compile-fail common/ops_on_union.cpp : $(LOOPHOLE_FLAT_DEF)               : flat_lh_on_union ]
-    [ compile-fail common/ops_on_union.cpp : $(CLASSIC_PREC_DEF)                : precise_on_union ]
-    [ compile-fail common/ops_on_union.cpp : $(LOOPHOLE_PREC_DEF)               : precise_lh_on_union ]
-
-    [ compile-fail common/ops_unions.cpp : $(CLASSIC_FLAT_DEF)                  : flat_unions ]
-    [ compile-fail common/ops_unions.cpp : $(LOOPHOLE_FLAT_DEF)                 : flat_lh_unions ]
-    [ compile-fail common/ops_unions.cpp : $(CLASSIC_PREC_DEF)                  : precise_unions ]
-    [ compile-fail common/ops_unions.cpp : $(LOOPHOLE_PREC_DEF)                 : precise_lh_unions ]
-
-    [ compile-fail common/ops_unrestricted_unions.cpp : $(CLASSIC_FLAT_DEF)     : flat_unrestricted_unions ]
-    [ compile-fail common/ops_unrestricted_unions.cpp : $(LOOPHOLE_FLAT_DEF)    : flat_lh_unrestricted_unions ]
-    [ compile-fail common/ops_unrestricted_unions.cpp : $(CLASSIC_PREC_DEF)     : precise_unrestricted_unions ]
-    [ compile-fail common/ops_unrestricted_unions.cpp : $(LOOPHOLE_PREC_DEF)    : precise_lh_unrestricted_unions ]
-
-    [ compile-fail common/non_std_layout.cpp : $(CLASSIC_FLAT_DEF)              : flat_non_standard_layout ]
-    [ compile-fail common/non_std_layout.cpp : $(LOOPHOLE_FLAT_DEF)             : flat_lh_non_standard_layout ]
-    [ run common/non_std_layout.cpp     : : : $(CLASSIC_PREC_DEF)               : precise_non_standard_layout ]
-    [ run common/non_std_layout.cpp     : : : $(LOOPHOLE_PREC_DEF)              : precise_lh_non_standard_layout ]
-
-    [ compile-fail common/non_default_constructible.cpp : $(CLASSIC_FLAT_DEF)   : flat_non_default_constructible ]
-    [ compile-fail common/non_default_constructible.cpp : $(LOOPHOLE_FLAT_DEF)  : flat_lh_non_sdefault_constructible ]
-    [ run common/non_default_constructible.cpp : : : $(CLASSIC_PREC_DEF)        : precise_non_default_constructible ]
-    [ run common/non_default_constructible.cpp : : : $(LOOPHOLE_PREC_DEF)       : precise_lh_non_default_constructible ]
-
-    [ compile-fail common/non_copyable_but_movable.cpp : $(CLASSIC_FLAT_DEF)    : flat_non_copyable_but_movable ]
-    [ run common/non_copyable_but_movable.cpp : : : $(LOOPHOLE_FLAT_DEF)        : flat_lh_non_copyable_but_movable ]
-    [ run common/non_copyable_but_movable.cpp : : : $(CLASSIC_PREC_DEF)         : precise_non_copyable_but_movable ]
-    [ run common/non_copyable_but_movable.cpp : : : $(LOOPHOLE_PREC_DEF)        : precise_lh_non_copyable_but_movable ]
-
-    [ compile-fail common/non_default_constructible_non_copyable_but_movable.cpp : $(CLASSIC_FLAT_DEF) : flat_non_dc_non_cop_but_mov ]
-    [ run common/non_default_constructible_non_copyable_but_movable.cpp : : : $(LOOPHOLE_FLAT_DEF)     : flat_lh_non_dc_non_cop_but_mov ]
-    [ run common/non_default_constructible_non_copyable_but_movable.cpp : : : $(CLASSIC_PREC_DEF)      : precise_non_dc_non_cop_but_mov ]
-    [ run common/non_default_constructible_non_copyable_but_movable.cpp : : : $(LOOPHOLE_PREC_DEF)     : precise_lh_non_dc_non_cop_but_mov ]
-
-    [ compile-fail common/fields_count_on_reference.cpp ]
-    [ run common/fields_count_on_const.cpp ]
-
-    ##### Flat tuple sizes
-    [ run common/test_tuple_sizes_on.cpp : : : $(DISABLE_ON_MSVC) <define>BOOST_PFR_RUN_TEST_ON=char : test_tuple_sizes_on_chars ]
-    [ run common/test_tuple_sizes_on.cpp : : : $(DISABLE_ON_MSVC) <define>BOOST_PFR_RUN_TEST_ON=int : test_tuple_sizes_on_ints ]
-    [ run common/test_tuple_sizes_on.cpp : : : $(DISABLE_ON_MSVC) <define>BOOST_PFR_RUN_TEST_ON=short : test_tuple_sizes_on_shorts ]
-    [ run common/test_tuple_sizes_on.cpp : : : $(DISABLE_ON_MSVC) <define>BOOST_PFR_RUN_TEST_ON=void* : test_tuple_sizes_on_voidptrs ]
-    [ run common/test_tuple_sizes_on.cpp : : : $(DISABLE_ON_MSVC) <define>BOOST_PFR_RUN_TEST_ON="std::size_t" : test_tuple_sizes_on_size_ts ]
-    #[ run common/test_tuple_sizes_on.cpp $(DISABLE_ON_MSVC)<define>BOOST_PFR_RUN_TEST_ON=char <define>BOOST_PFR_RUN_HUGE_TESTS : test_tuple_sizes_on_chars_huge ]
-
-
-    ##### Flat specific tests
-    [ run flat/core.cpp                     : : : $(CLASSIC_FLAT_DEF) ]
-    [ run flat/flat_tuple_size.cpp          : : : $(CLASSIC_FLAT_DEF) ]
-    [ run flat/flat_motivating_example.cpp  : : : $(CLASSIC_FLAT_DEF) ]
-    [ run flat/flat_for_each_field.cpp      : : : $(CLASSIC_FLAT_DEF) ]
-    [ run flat/destructuring_tie.cpp        : : : $(CLASSIC_FLAT_DEF) ]
-    [ compile-fail flat/flat_tuple_size_on_non_aggregate.cpp    : $(CLASSIC_FLAT_DEF) ]
-    [ compile-fail flat/flat_tuple_size_on_bitfields.cpp        : $(CLASSIC_FLAT_DEF) ]
-
-
-    ##### Precise specific tests
-    [ run precise/tuple_size.cpp                    : : : $(CLASSIC_PREC_DEF) : precise_tuple_size ]
-    [ run precise/bitfields.cpp                     : : : $(CLASSIC_PREC_DEF) : precise_tuple_size_on_bitfields ]
-    [ run precise/for_each_field.cpp                : : : $(CLASSIC_PREC_DEF) : precise_for_each_field ]
-    [ run precise/motivating_example0.cpp           : : : $(CLASSIC_PREC_DEF) : precise_motivating_example0 ]
-    [ run precise/motivating_example.cpp            : : : $(CLASSIC_PREC_DEF) : precise_motivating_example ]
-    [ run precise/motivating_example2.cpp           : : : $(CLASSIC_PREC_DEF) : precise_motivating_example2 ]
-    [ run precise/optional_like.cpp                 : : : $(CLASSIC_PREC_DEF) : precise_optional_like ]
-    [ run precise/get_non_default_constructible.cpp : : : $(CLASSIC_PREC_DEF) : precise_get_non_default_constructible ]
-    [ run precise/destructuring_tie.cpp             : : : $(CLASSIC_PREC_DEF) : precise_destructuring_tie ]
-    [ run precise/error_pfr_c1202.cpp               : : : $(CLASSIC_PREC_DEF) : precise_c1202_issue21 ]
-    [ compile-fail precise/non_aggregate.cpp        : $(CLASSIC_PREC_DEF)     : precise_non_aggregate ]
-
-    # See "Requirements and Limitations" section of the docs for info on following tests:
-    #[ compile-fail precise/template_constructor.cpp   : $(CLASSIC_PREC_DEF) [ requires !cxx17_structured_bindings ] : precise_template_constructor14 ]
-    #[ compile-fail precise/template_unconstrained.cpp : $(CLASSIC_PREC_DEF) [ requires !cxx17_structured_bindings ] : precise_template_unconstrained14 ]
-    [ run precise/template_constructor.cpp          : : : $(CLASSIC_PREC_DEF) [ requires cxx17_structured_bindings ] : precise_template_constructor ]
-    # TODO:
-    #[ run precise/template_unconstrained.cpp        : : : $(CLASSIC_PREC_DEF) [ requires cxx17_structured_bindings ] : precise_template_unconstrained ]
-
-    # The following tests may compile of fail depending on C++ Standard version.
-    #[ compile-fail precise/issue30.cpp              : $(CLASSIC_PREC_DEF) : precise_issue30 ]
-    #[ compile-fail precise/issue33.cpp              : $(CLASSIC_PREC_DEF) : precise_issue33 ]
-
-
-    ##### Loophole tests running precise and flat specific tests
-    [ run flat/core.cpp                             : : : $(LOOPHOLE_FLAT_DEF) : flat_lh_core ]
-    [ run flat/flat_tuple_size.cpp                  : : : $(LOOPHOLE_FLAT_DEF) : flat_lh_tuple_size ]
-    [ run flat/flat_motivating_example.cpp          : : : $(LOOPHOLE_FLAT_DEF) : flat_lh_motivating_example ]
-    [ run flat/flat_for_each_field.cpp              : : : $(LOOPHOLE_FLAT_DEF) : flat_lh_for_each_field ]
-    [ compile-fail flat/flat_tuple_size_on_non_aggregate.cpp    : $(LOOPHOLE_FLAT_DEF) : flat_lh_tuple_size_on_non_aggregate ]
-    [ compile-fail flat/flat_tuple_size_on_bitfields.cpp        : $(LOOPHOLE_FLAT_DEF) : flat_lh_tuple_size_on_bitfields ]
-
-    [ run precise/tuple_size.cpp                    : : : $(LOOPHOLE_PREC_DEF) : precise_lh_tuple_size ]
-    [ run precise/bitfields.cpp                     : : : $(LOOPHOLE_PREC_DEF) : precise_lh_tuple_size_on_bitfields ]
-    [ run precise/for_each_field.cpp                : : : $(LOOPHOLE_PREC_DEF) : precise_lh_for_each_field ]
-    [ run precise/motivating_example0.cpp           : : : $(LOOPHOLE_PREC_DEF) : precise_lh_motivating_example0 ]
-    [ run precise/motivating_example.cpp            : : : $(LOOPHOLE_PREC_DEF) : precise_lh_motivating_example ]
-    [ run precise/motivating_example2.cpp           : : : $(LOOPHOLE_PREC_DEF) : precise_lh_motivating_example2 ]
-    [ run precise/optional_like.cpp                 : : : $(LOOPHOLE_PREC_DEF) : precise_lh_optional_like ]
-    [ run precise/get_non_default_constructible.cpp : : : $(LOOPHOLE_PREC_DEF) : precise_lh_get_non_default_constructible ]
-    [ run precise/error_pfr_c1202.cpp               : : : $(LOOPHOLE_PREC_DEF) : precise_lh_c1202_issue21 ]
-    [ run precise/issue30.cpp                       : : : $(LOOPHOLE_PREC_DEF) : precise_lh_issue30 ]
-    [ run precise/issue33.cpp                       : : : $(LOOPHOLE_PREC_DEF) : precise_lh_issue33 ]
-    [ compile-fail precise/non_aggregate.cpp        : $(LOOPHOLE_PREC_DEF) : precise_lh_non_aggregate ]
-
-    # See "Requirements and Limitations" section of the docs for info on following tests:
-    #[ compile-fail precise/template_constructor.cpp   : $(LOOPHOLE_PREC_DEF) [ requires !cxx17_structured_bindings ] : precise_lh_template_constructor14 ]
-    #[ compile-fail precise/template_unconstrained.cpp : $(LOOPHOLE_PREC_DEF) [ requires !cxx17_structured_bindings ] : precise_lh_template_unconstrained14 ]
-    [ run precise/template_constructor.cpp   : : : $(LOOPHOLE_PREC_DEF) [ requires cxx17_structured_bindings ] : precise_lh_template_constructor ]
-    # TODO:
-    #[ run precise/template_unconstrained.cpp : : : $(LOOPHOLE_PREC_DEF) [ requires cxx17_structured_bindings ] : precise_lh_template_unconstrained ]
-
-
-    # Examples from docs
-    [ run ../example/examples.cpp : : : $(DISABLE_ON_MSVC) ]
-    [ run ../example/quick_examples.cpp : : : $(DISABLE_ON_MSVC) ]
-  ;
-
-

test/appveyor.yml

@@ -2,7 +2,7 @@
 # subject to the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #
-# Copyright Antony Polukhin 2016-2019.
+# Copyright Antony Polukhin 2016-2021.
 
 #
 # See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
@@ -11,13 +11,17 @@
 # File revision #6 (with DIFF)
 
 init:
-    - set BOOST_REMOVE=%APPVEYOR_PROJECT_NAME%         # Remove this folder from lib from full clone of Boost.
+    # boost-local/libs/ folder to put this library into. This may be useful, if you're for example running Travis
+    # from `Boost.DLL` repo while Boost already has `dll` and with to replace `dll` with content of`Boost.DLL`.
+    #
+    # Otherwise just leave the default value - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
+    - set BOOST_LIBS_FOLDER=pfr # DIFF
 
 ###############################################################################################################
 # From this point and below code is same for all the Boost libs
 ###############################################################################################################
 
-version: 1.64.{build}-{branch}
+version: 1.74.{build}-{branch}
  
 # branches to build
 branches:
@@ -28,6 +32,14 @@ skip_tags: true
 
 environment:
   matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0
+      ADDRMD: 32
+      CXXSTD: latest # fake
+#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+#      TOOLSET: msvc # TODO: clang-win ???
+#      ADDRMD: 32,64
+#      CXXSTD: 17,latest
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc # clang-win has problems with structured bindings - it can not correclty use std::tuple_size
       ADDRMD: 32,64
@@ -60,22 +72,22 @@ environment:
 before_build:
     - set BOOST_BRANCH=develop
     - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-    - echo "Testing %APPVEYOR_PROJECT_NAME%"
+    - echo "Testing %BOOST_LIBS_FOLDER%"
     # Cloning Boost libraries (fast nondeep cloning)
     - set BOOST=C:/boost-local
     - git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git %BOOST%
     - cd %BOOST%
-    - git submodule update --init --depth 10 tools/build tools/boostdep libs/type_index # DIFF: Added libs/type_index
+    - git submodule update --init --depth 10 tools/build tools/boostdep
 
-    - rm -rf %BOOST%/libs/%BOOST_REMOVE%
-    - mv %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%APPVEYOR_PROJECT_NAME%
-    - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" %APPVEYOR_PROJECT_NAME%
-    - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" type_index # DIFF: Added
+    - echo "rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%"
+    - rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%
+    - mv %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%BOOST_LIBS_FOLDER%
+    - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" -I example -I examples %BOOST_LIBS_FOLDER%
 
 build_script:
     - cmd /c bootstrap
     - b2.exe headers
-    - cd %BOOST%/libs/%APPVEYOR_PROJECT_NAME%/test
+    - cd %BOOST%/libs/%BOOST_LIBS_FOLDER%/test
 
 after_build:
 before_test:

test/common/global_ops.cpp

@@ -1,126 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-#ifdef BOOST_PFR_TEST_FLAT
-#   include <boost/pfr/flat/global_ops.hpp>
-#elif defined(BOOST_PFR_TEST_PRECISE)
-#   include <boost/pfr/precise/global_ops.hpp>
-#else
-#   error Misused test
-#endif
-
-
-#include <boost/core/lightweight_test.hpp>
-
-#include <iostream>
-#include <typeinfo>
-#include <tuple>
-#include <sstream>
-#include <set>
-#include <string>
-#include <unordered_set>
-
-
-#define BOOST_HASH_NO_EXTENSIONS
-#include <boost/container_hash/hash.hpp>
-
-template <class T>
-void test_comparable_struct() {
-    T s1 {0, 1, false, 6,7,8,9,10,11};
-    T s2 = s1;
-    T s3 {0, 1, false, 6,7,8,9,10,11111};
-    BOOST_TEST(s1 == s2);
-    BOOST_TEST(s1 <= s2);
-    BOOST_TEST(s1 >= s2);
-    BOOST_TEST(!(s1 != s2));
-    BOOST_TEST(!(s1 == s3));
-    BOOST_TEST(s1 != s3);
-    BOOST_TEST(s1 < s3);
-    BOOST_TEST(s3 > s2);
-    BOOST_TEST(s1 <= s3);
-    BOOST_TEST(s3 >= s2);
-
-    std::cout << s1 << std::endl;
-
-    T s4;
-    std::stringstream ss;
-    ss.exceptions ( std::ios::failbit);
-    ss << s1;
-    ss >> s4;
-    std::cout << s4 << std::endl;
-    BOOST_TEST(s1 == s4);
-    int i = 1, j = 2;
-    BOOST_TEST_NE(i, j);
-}
-
-void test_empty_struct() {
-    struct empty {};
-
-    std::cout << empty{};
-    BOOST_TEST(empty{} == empty{});
-}
-
-struct adl_hash {
-    template <class T>
-    std::size_t operator()(const T& val) const {
-        using namespace boost;
-        return hash_value(val);
-    }
-};
-
-template <class Comparator>
-void test_with_contatiners() {
-    struct testing { bool b1, b2; int i; };
-
-    std::set<testing, Comparator > t{
-        {true, true, 100},
-        {false, true, 100},
-        {true, false, 100},
-        {true, true, 101}
-    };
-
-    BOOST_TEST(t.find({true, true, 100}) != t.end());
-    BOOST_TEST_EQ(t.count({true, true, 100}), 1u);
-
-    std::unordered_set<testing, adl_hash> us(t.begin(), t.end());
-    BOOST_TEST_EQ(us.size(), t.size());
-}
-
-
-namespace foo {
-struct comparable_struct {
-    int i; short s; bool bl; int a,b,c,d,e,f;
-};
-}
-
-
-void test_implicit_conversions() {
-    std::stringstream ss;
-    ss << std::true_type{};
-    BOOST_TEST_EQ(ss.str(), "{}"); // Breaks implicit conversion :(
-}
-
-int main() {
-    test_comparable_struct<foo::comparable_struct>();
-
-    struct local_comparable_struct {
-        int i; short s; bool bl; int a,b,c,d,e,f;
-    };
-
-    test_comparable_struct<local_comparable_struct>();
-
-    test_empty_struct();
-#ifndef BOOST_CLANG
-    // TODO: Fails for unknown reason on Clang
-    test_with_contatiners<std::less<>>();
-    test_with_contatiners<std::greater<>>();
-#endif
-    test_implicit_conversions();
-
-    return boost::report_errors();
-}
-
-

test/common/ops_on_union.cpp

@@ -1,26 +0,0 @@
-// Copyright (c) 2018 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <string>
-
-#ifdef BOOST_PFR_TEST_FLAT
-#include <boost/pfr/flat/ops.hpp>
-using namespace boost::pfr::flat_ops;
-#endif
-
-#ifdef BOOST_PFR_TEST_PRECISE
-#include <boost/pfr/precise/ops.hpp>
-using namespace boost::pfr::ops;
-#endif
-
-union test_union {
-    const char* c;
-    int i;
-};
-
-int main() {
-    test_union v{""};
-    return v == v;
-}

test/common/test_tuple_sizes_on.cpp

@@ -1,128 +0,0 @@
-// Copyright (c) 2016-2020 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/pfr/flat/core.hpp>
-#include <boost/pfr/precise/core.hpp>
-
-template <class T1, std::size_t CountInT, std::size_t CountHelpers>
-void test_counts_on_multiple_chars_impl_1() {
-    using boost::pfr::flat_tuple_size_v;
-    using boost::pfr::tuple_size_v;
-
-    struct t1_c { T1 v1; char c[CountHelpers]; };
-    static_assert(flat_tuple_size_v<t1_c> == CountInT + CountHelpers, "");
-
-    struct t1_s { T1 v1; short s[CountHelpers]; };
-    static_assert(flat_tuple_size_v<t1_s> == CountInT + CountHelpers, "");
-
-    struct t1_i { T1 v1; const int i[CountHelpers]; };
-    static_assert(flat_tuple_size_v<t1_i> == CountInT + CountHelpers, "");
-
-    struct t1_p { T1 v1; void* p[CountHelpers]; };
-    static_assert(flat_tuple_size_v<t1_p> == CountInT + CountHelpers, "");
-
-    struct t1_ll { T1 v1; long long ll[CountHelpers]; };
-    static_assert(flat_tuple_size_v<t1_ll> == CountInT + CountHelpers, "");
-
-
-    struct rt1_c { char c[CountHelpers]; T1 v1; };
-    static_assert(flat_tuple_size_v<rt1_c> == CountInT + CountHelpers, "");
-
-    struct rt1_s { const short s[CountHelpers]; T1 v1; };
-    static_assert(flat_tuple_size_v<rt1_s> == CountInT + CountHelpers, "");
-
-    struct rt1_i { int i[CountHelpers]; T1 v1; };
-    static_assert(flat_tuple_size_v<rt1_i> == CountInT + CountHelpers, "");
-
-    struct rt1_p { void* p[CountHelpers]; T1 v1; };
-    static_assert(flat_tuple_size_v<rt1_p> == CountInT + CountHelpers, "");
-
-    struct rt1_ll { long long ll[CountHelpers]; T1 v1; };
-    static_assert(flat_tuple_size_v<rt1_ll> == CountInT + CountHelpers, "");
-
-    struct rt1_ll_1 { rt1_ll v1; };
-    static_assert(flat_tuple_size_v<rt1_ll_1> == CountInT + CountHelpers, "");
-    static_assert(tuple_size_v<rt1_ll_1> == 1, "");
-}
-
-template <class T1, std::size_t CountInT>
-void test_counts_on_multiple_chars_impl() {
-    using boost::pfr::flat_tuple_size_v;
-    using boost::pfr::tuple_size_v;
-
-    struct t1_0 { T1 v1; };
-    static_assert(flat_tuple_size_v<t1_0> == CountInT, "");
-    static_assert(flat_tuple_size_v<T1> == CountInT, "");
-    static_assert(flat_tuple_size_v<std::conditional_t<std::is_fundamental<T1>::value, T1*, void*> > == 1, "");
-#if !defined(__GNUC__) || __GNUC__ != 8
-    // GCC-8 has big problems with this test:
-    //    error: ‘constexpr ubiq_constructor::operator Type&() const [with Type = test_counts_on_multiple_chars()::t2*]’,
-    //    declared using local type ‘test_counts_on_multiple_chars()::t2’, is used but never defined [-fpermissive]
-    //
-    // Fixed in GCC-9.
-    static_assert(tuple_size_v<T1*> == 1, "");
-#endif
-
-    struct t1_0_1 { t1_0 t1; };
-    static_assert(flat_tuple_size_v<t1_0_1> == CountInT, "");
-    static_assert(tuple_size_v<t1_0_1> == 1, "");
-
-    struct t1_0_2 { t1_0 t1; t1_0 t2; };
-    static_assert(flat_tuple_size_v<t1_0_2> == CountInT * 2, "");
-    static_assert(tuple_size_v<t1_0_2> == 2, "");
-
-    static_assert(flat_tuple_size_v<T1[5]> == CountInT * 5, "");
-
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 1>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 2>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 3>();
-#ifdef BOOST_PFR_RUN_HUGE_TESTS
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 4>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 5>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 6>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 7>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 8>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 9>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 10>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 11>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 12>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 13>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 14>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 15>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 16>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 17>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 18>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 19>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 20>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 23>();
-    test_counts_on_multiple_chars_impl_1<T1, CountInT, 24>();
-#endif
-}
-
-template <class T>
-void test_counts_on_multiple_chars() {
-    using boost::pfr::tuple_size_v;
-
-    test_counts_on_multiple_chars_impl<T, 1>();
-
-    struct t2 { T v1; T v2; };
-    static_assert(tuple_size_v<t2> == 2, "");
-
-    test_counts_on_multiple_chars_impl<t2, 2>();
-    test_counts_on_multiple_chars_impl<T[2], 2>();
-
-    test_counts_on_multiple_chars_impl<T[3], 3>();
-    test_counts_on_multiple_chars_impl<T[4], 4>();
-
-    struct t8 { T v1; T v2; T v3; T v4; T v5; T v6; T v7; T v8; };
-    test_counts_on_multiple_chars_impl<t8, 8>();
-}
-
-int main() {
-    test_counts_on_multiple_chars< BOOST_PFR_RUN_TEST_ON >();
-
-    return 0;
-}
-

test/config/Jamfile.v2

@@ -0,0 +1,22 @@
+#  Copyright (C) 2023 Denis Mikhailov
+#
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import python ;
+import testing ;
+import ../../config/checks/config : requires ;
+
+project
+    : source-location .
+    : requirements
+        <define>BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING=1
+    ;
+
+
+test-suite pfr_tests
+  :
+    [ run print_config.cpp : : : <test-info>always_show_run_output : auto_engine_config ]
+  ;

test/config/print_config.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/config.hpp> // inclusion of an another PFR header may fail when BOOST_PFR_ENABLED=0
+
+#include <iostream>
+
+int main() {
+    std::cout << "Platform info:" << '\n'
+        << "BOOST_PFR_USE_CPP17 == " << BOOST_PFR_USE_CPP17 << '\n'
+        << "BOOST_PFR_USE_LOOPHOLE == " << BOOST_PFR_USE_LOOPHOLE << '\n'
+        << "BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == " << BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE << '\n'
+        << "BOOST_PFR_HAS_GUARANTEED_COPY_ELISION == " << BOOST_PFR_HAS_GUARANTEED_COPY_ELISION << '\n'
+        << "BOOST_PFR_ENABLE_IMPLICIT_REFLECTION == " << BOOST_PFR_ENABLE_IMPLICIT_REFLECTION << '\n'
+        << "BOOST_PFR_ENABLED == " << BOOST_PFR_ENABLED << '\n'
+        << "__cplusplus == " << __cplusplus << '\n'
+#ifdef __cpp_structured_bindings
+        << "__cpp_structured_bindings == " << __cpp_structured_bindings << '\n'
+#endif
+#ifdef _MSC_VER
+        << "_MSC_VER == " << _MSC_VER << '\n'
+#endif
+#ifdef _MSVC_LANG
+        << "_MSVC_LANG == " << _MSVC_LANG << '\n'
+#endif
+#ifdef __GLIBCXX__
+        << "__GLIBCXX__ == " << __GLIBCXX__ << '\n'
+#endif
+#ifdef __GNUC__
+        << "__GNUC__ == " << __GNUC__ << '\n'
+#endif
+#ifdef __clang_major__
+        << "__clang_major__ == " << __clang_major__ << '\n'
+#endif
+    ;
+}

test/core/Jamfile.v2

@@ -0,0 +1,133 @@
+#  Copyright (C) 2016-2023 Antony Polukhin.
+#
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import python ;
+import testing ;
+import ../../config/checks/config : requires ;
+
+project
+    : source-location .
+    : requirements
+        <define>BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING=1
+        [ requires cxx14_constexpr ]
+    ;
+
+########## BEGIN of helpers to detect Loophole trick support
+
+actions mp_simple_run_action
+{
+      $(>) > $(<)
+}
+
+rule mp-run-simple ( sources + : args * : input-files * : requirements * : target-name )
+{
+   exe $(target-name)_exe : $(sources) : $(requirements) ;
+   explicit $(target-name)_exe ;
+   make $(target-name).output : $(target-name)_exe : @mp_simple_run_action ;
+   explicit $(target-name).output ;
+   alias $(target-name) : $(target-name).output ;
+}
+
+mp-run-simple loophole_detection.cpp : : : : compiler_supports_loophole ;
+explicit compiler_supports_loophole ;
+
+########## END of helpers to detect Loophole trick support
+
+
+local DISABLE_ON_MSVC = ; #<toolset>msvc:<build>no ;
+local REQUIRE_LOOPHOLE =
+    [ check-target-builds ../core//compiler_supports_loophole : : <build>no ]
+  ;
+
+local STRUCTURED_BINDING_ENGINE = <define>BOOST_PFR_USE_LOOPHOLE=0 <define>BOOST_PFR_USE_CPP17=1 [ requires cxx17_structured_bindings ] ;
+local LOOPHOLE_ENGINE = <define>BOOST_PFR_USE_LOOPHOLE=1 <define>BOOST_PFR_USE_CPP17=0 $(REQUIRE_LOOPHOLE) ;
+local CLASSIC_ENGINE = <define>BOOST_PFR_USE_LOOPHOLE=0 <define>BOOST_PFR_USE_CPP17=0 $(DISABLE_ON_MSVC) ;
+
+test-suite pfr_tests
+  :
+    [ run offset_based_getter.cpp ]
+
+    [ run can_be_as_fallback_in_the_fusion.cpp ]
+
+    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=char : test_tuple_sizes_on_chars ]
+    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=int : test_tuple_sizes_on_ints ]
+    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=short : test_tuple_sizes_on_shorts ]
+    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=void* : test_tuple_sizes_on_voidptrs ]
+    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON="std::size_t" : test_tuple_sizes_on_size_ts ]
+
+    [ run run/motivating_example.cpp      : : : : auto_engine_motivating ]
+    [ run ../../example/sample_printing.cpp  : : : : auto_engine_sample_printing ]
+    [ run ../../example/get.cpp              : : : : auto_engine_get ]
+    [ run ../../example/quick_examples.cpp   : : : : auto_engine_quick ]
+  ;
+
+local BLACKLIST_TESTS_FOR_LOOPHOLE =
+    constexpr_ops                       # Loophole is not constexpr usable because of the reinterpret_cast usage
+    get_const_field                     # boost::pfr::get gives compile time error on const fields
+    optional_chrono                     # boost::pfr::* has problems with std::optional, produces compile time error
+    template_constructor                # Template constructor in one of the fields of the aggregate
+    tie_anonymous_const_field           # boost::pfr::structure_tie gives compile time error on const fields
+  ;
+
+# Those tests are either 
+# * reflecting a non literal type
+# * or calling boost::pfr::get and the result is a user defined structure
+local BLACKLIST_TESTS_FOR_CLASSIC =
+    constexpr_ops
+    get_const_field
+    get_non_default_constructible
+    get_rvalue
+    issue30
+    issue33
+    motivating_example0
+    motivating_example2
+    optional_chrono
+    optional_like
+    read_write_non_literal
+    template_constructor
+    template_forwarding_ref
+    template_unconstrained
+    tie_anonymous
+    tie_anonymous_const_field
+  ;
+
+for local source_file in [ glob ./run/*.cpp ] [ glob ../../example/*.cpp ]
+{
+    local target_name = $(source_file[1]:B) ;
+    pfr_tests += [ run $(source_file) : : : $(STRUCTURED_BINDING_ENGINE) : $(target_name)_sb ] ;
+    
+    if ! $(target_name) in $(BLACKLIST_TESTS_FOR_LOOPHOLE)
+    {
+        pfr_tests += [ run $(source_file) : : : $(LOOPHOLE_ENGINE) : $(target_name)_lh ] ;
+    }
+    else
+    {
+        pfr_tests += [ compile-fail $(source_file) : $(LOOPHOLE_ENGINE) : $(target_name)_lh ] ;
+    }
+
+    if ! $(target_name) in $(BLACKLIST_TESTS_FOR_CLASSIC)
+    {
+        pfr_tests += [ run $(source_file) : : : $(CLASSIC_ENGINE) : $(target_name)_classic ] ;
+    }
+    else
+    {
+        pfr_tests += [ compile-fail $(source_file) : $(CLASSIC_ENGINE) : $(target_name)_classic ] ;
+    }
+}
+
+for local source_file in [ glob ./compile-fail/*.cpp ]
+{
+    local target_name = $(source_file[1]:B) ;
+    pfr_tests += [ compile-fail $(source_file) : $(STRUCTURED_BINDING_ENGINE) : $(target_name)_sb ] ;
+    pfr_tests += [ compile-fail $(source_file) : $(LOOPHOLE_ENGINE) : $(target_name)_lh ] ;
+    pfr_tests += [ compile-fail $(source_file) : $(CLASSIC_ENGINE) : $(target_name)_classic ] ;
+}
+
+if [ python.configured ]
+{
+    testing.make-test run-pyd : ../../misc/generate_cpp17.py ;
+}

test/core/can_be_as_fallback_in_the_fusion.cpp

@@ -0,0 +1,37 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <type_traits>
+
+struct Aggregate {};
+using NonAggregate = int;
+
+template<class T>
+struct is_implicitly_reflectable : std::false_type
+{};
+
+template<>
+struct is_implicitly_reflectable<Aggregate> : std::true_type
+{};
+
+template<class T, class E=void>
+struct tag_of_fallback {
+    using type = int; // unknown
+};
+
+template<class T>
+struct tag_of_fallback<T, std::enable_if_t<std::is_same<T,T>::value>>
+{
+    using type = std::conditional_t<
+        is_implicitly_reflectable<T>::value
+      , std::true_type
+      , std::false_type
+    >;
+};
+
+static_assert(tag_of_fallback<Aggregate>::type::value == true, "");
+static_assert(tag_of_fallback<NonAggregate>::type::value == false, "");
+
+int main() { }

test/core/compile-fail/boost_pfr_disabled_via_macro.cpp

@@ -0,0 +1,10 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_PFR_ENABLED 0
+#include <boost/pfr/core.hpp>
+
+int main() { }
+

test/core/compile-fail/fields_count_on_reference.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -11,5 +11,5 @@ struct some_struct {
 };
 
 int main() {
-    return boost::pfr::detail::fields_count<some_struct&>();
+    return static_cast<int>(boost::pfr::detail::fields_count<some_struct&>());
 }

test/core/compile-fail/inherited.cpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2021 Denis Mikhailov
+// Copyright (c) 2021 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/core.hpp>
+
+struct A
+{};
+
+struct B : A
+{
+    int one;
+    int two;
+};
+
+int main() {
+    (void)boost::pfr::tuple_size<B>::value; // Must be a compile time error
+}
+

test/core/compile-fail/inherited_nonempty.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2021 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/core.hpp>
+
+struct A {
+    int zero;
+};
+
+struct B : public A {
+    int one;
+    int two;
+};
+
+int main() {
+    (void)boost::pfr::tuple_size<B>::value; // Must be a compile time error
+}
+

test/core/compile-fail/movable_and_lvalue_references.cpp

@@ -1,10 +1,9 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
+#include <boost/pfr/tuple_size.hpp>
 
 struct X {
     X() = default;
@@ -21,10 +20,6 @@ struct test_lvalue_ref_and_movable {
 };
 
 int main() {
-#ifdef BOOST_PFR_TEST_FLAT
-    return boost::pfr::flat_tuple_size<test_lvalue_ref_and_movable>::value;
-#else
     return boost::pfr::tuple_size<test_lvalue_ref_and_movable>::value;
-#endif
 }
 

test/core/compile-fail/non_aggregate.cpp

@@ -1,9 +1,9 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/precise/core.hpp>
+#include <boost/pfr/core.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 #include <tuple>

test/core/compile-fail/ops_on_union.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2018-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <string>
+
+#include <boost/pfr/ops.hpp>
+
+union test_union {
+    const char* c;
+    int i;
+};
+
+int main() {
+    test_union v{""};
+    return boost::pfr::eq(v, v);
+}

test/core/compile-fail/ops_unions.cpp

@@ -1,19 +1,11 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <string>
 
-#ifdef BOOST_PFR_TEST_FLAT
-#include <boost/pfr/flat/ops.hpp>
-using namespace boost::pfr::flat_ops;
-#endif
-
-#ifdef BOOST_PFR_TEST_PRECISE
-#include <boost/pfr/precise/ops.hpp>
-using namespace boost::pfr::ops;
-#endif
+#include <boost/pfr/ops.hpp>
 
 union test_union {
     const char* c;
@@ -26,5 +18,5 @@ int main() {
     };
 
     two_unions v{{""}, {""}};
-    return v == v;
+    return boost::pfr::eq(v, v);
 }

test/core/compile-fail/ops_unrestricted_unions.cpp

@@ -1,18 +1,14 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/pfr/ops.hpp>
+
 #include <string>
 
-#ifdef BOOST_PFR_TEST_FLAT
-#include <boost/pfr/flat/ops.hpp>
-using namespace boost::pfr::flat_ops;
-#endif
-
-#ifdef BOOST_PFR_TEST_PRECISE
-#include <boost/pfr/precise/ops.hpp>
-using namespace boost::pfr::ops;
+#if defined(_MSC_VER)
+# pragma warning( disable: 4624 ) // destructor was implicitly defined as deleted
 #endif
 
 union test_unrestricted_union {
@@ -28,5 +24,5 @@ int main() {
     // Not calling the destructor intentionally!
     auto v = new two_unions{{1}, {1}};
 
-    return *v == *v;
+    return boost::pfr::eq(*v, *v);
 }

test/core/compile-fail/pfr_review_test2.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2020-2023 Antony Polukhin
+// Copyright (c) 2020 Richard Hodges
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Test case from https://github.com/madmongo1/pfr_review/blob/master/pre-cxx20/test-2.cpp
+
+#include <boost/pfr/functions_for.hpp>
+
+#include <boost/utility/string_view.hpp>
+
+#include <sstream>
+#include <string>
+
+#include <boost/core/lightweight_test.hpp>
+
+namespace the_wild {
+    struct animal {
+        std::string        name;
+        boost::string_view temperament;
+    };
+    
+    // Error: std::hash not specialized for type
+    // OR in C++14:
+    // Error: animal is not constexpr initializable
+    BOOST_PFR_FUNCTIONS_FOR(animal)
+} // namespace the_wild
+
+const auto fido = the_wild::animal { "fido", "aloof" };
+
+int main() {
+    std::ostringstream oss;
+    oss << fido;
+
+    BOOST_TEST_EQ(oss.str(), "{\"fido\", \"aloof\"}");
+
+    return boost::report_errors();
+}

test/core/compile-fail/private_fields.cpp

@@ -1,10 +1,14 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
+#include <boost/pfr/tuple_size.hpp>
+
+#ifdef __clang__
+#   pragma clang diagnostic ignored "-Wunused-private-field"
+#endif
+
 
 class test_with_private {
 private:
@@ -17,15 +21,10 @@ public:
 };
 
 int main() {
-#ifdef BOOST_PFR_TEST_FLAT
-    return boost::pfr::flat_tuple_size<test_with_private>::value;
-#else
-
 #ifndef __cpp_lib_is_aggregate
 #   error No known way to detect private fields.
 #endif
 
     return boost::pfr::tuple_size<test_with_private>::value;
-#endif
 }
 

test/core/compile-fail/protected_fields.cpp

@@ -1,10 +1,9 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
+#include <boost/pfr/tuple_size.hpp>
 
 class test_with_protected {
 protected:
@@ -17,15 +16,11 @@ public:
 };
 
 int main() {
-#ifdef BOOST_PFR_TEST_FLAT
-    return boost::pfr::flat_tuple_size<test_with_protected>::value;
-#else
-
 #ifndef __cpp_lib_is_aggregate
+// TODO: No known way to detect protected fields
 #   error No known way to detect protected fields.
 #endif
 
     return boost::pfr::tuple_size<test_with_protected>::value;
-#endif
 }
 

test/core/compile-fail/rvalue_tie.cpp

@@ -0,0 +1,17 @@
+// Copyright (c) 2020-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/core.hpp>
+
+#include <string>
+
+struct test_struct {
+    int i;
+    std::string s;
+};
+
+int main() {
+    boost::pfr::structure_tie(test_struct{1, "test"});
+}

test/core/compile-fail/virtual_functions.cpp

@@ -1,10 +1,9 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/flat/tuple_size.hpp>
-#include <boost/pfr/precise/tuple_size.hpp>
+#include <boost/pfr/tuple_size.hpp>
 
 struct test_with_virtual {
     int i = 0;
@@ -16,10 +15,6 @@ struct test_with_virtual {
 };
 
 int main() {
-#ifdef BOOST_PFR_TEST_FLAT
-    return boost::pfr::flat_tuple_size<test_with_virtual>::value;
-#else
     return boost::pfr::tuple_size<test_with_virtual>::value;
-#endif
 }
 

test/core/loophole_detection.cpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2020-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Detection of type loophole.
+// Inspired by the blog post: http://alexpolt.github.io/type-loophole.html
+
+#include <type_traits>
+
+#if defined(_MSC_VER) && _MSC_VER <= 1916
+#   error Compiler fails to do compile time computations for LoopHole. Fixed in later versions of the compiler
+// Error: boost/pfr/detail/core14_loophole.hpp(98): error C3779: 'boost::pfr::detail::loophole': a function that returns 'auto' cannot be used before it is defined
+#endif
+
+
+template <unsigned> struct tag{};
+
+template <class T, unsigned N>
+struct loophole_t {
+  friend auto loophole(tag<N>) { return T{}; };
+};
+
+auto loophole(tag<0>);
+
+int main() {
+   sizeof(loophole_t<unsigned, 0>);
+   static_assert( std::is_same<unsigned, decltype( loophole(tag<0>{}) ) >::value, "");
+}

test/core/offset_based_getter.cpp

@@ -1,5 +1,5 @@
 // Copyright (c) 2019 Ilya Kiselev
-// Copyright (c) 2019-2020 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

test/core/run/bitfields_count.cpp

@@ -1,10 +1,9 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/precise/core.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/pfr/tuple_size.hpp>
 
 struct bf {
     unsigned int i1: 1;
@@ -16,8 +15,7 @@ struct bf {
 };
 
 int main() {
-    (void)boost::pfr::tuple_size<bf>::value;
-    return boost::report_errors();
+    static_assert(boost::pfr::tuple_size<bf>::value == 6, "");
 }
 
 

test/core/run/constexpr_ops.cpp

@@ -0,0 +1,81 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/ops.hpp>
+#include <boost/pfr/io.hpp>
+
+#include <iostream>
+#include <typeinfo>
+#include <tuple>
+#include <sstream>
+#include <set>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#ifdef __clang__
+#   pragma clang diagnostic ignored "-Wmissing-braces"
+#endif
+
+union test_union {
+    int i;
+    float f;
+};
+
+constexpr bool operator< (test_union l, test_union r) noexcept { return l.i <  r.i; }
+constexpr bool operator<=(test_union l, test_union r) noexcept { return l.i <= r.i; }
+constexpr bool operator> (test_union l, test_union r) noexcept { return l.i >  r.i; }
+constexpr bool operator>=(test_union l, test_union r) noexcept { return l.i >= r.i; }
+constexpr bool operator==(test_union l, test_union r) noexcept { return l.i == r.i; }
+constexpr bool operator!=(test_union l, test_union r) noexcept { return l.i != r.i; }
+
+
+template <class T>
+void test_constexpr_comparable() {
+    using namespace boost::pfr;
+    constexpr T s1 {110, 1, true, 6,17,8,9,10,11};
+    constexpr T s2 = s1;
+    constexpr T s3 {110, 1, true, 6,17,8,9,10,11111};
+    static_assert(eq(s1, s2), "");
+    static_assert(le(s1, s2), "");
+    static_assert(ge(s1, s2), "");
+    static_assert(!ne(s1, s2), "");
+    static_assert(!eq(s1, s3), "");
+    static_assert(ne(s1, s3), "");
+    static_assert(lt(s1, s3), "");
+    static_assert(gt(s3, s2), "");
+    static_assert(le(s1, s3), "");
+    static_assert(ge(s3, s2), "");
+}
+
+namespace foo {
+struct comparable_struct {
+    int i; short s; bool bl; int a,b,c,d,e,f;
+};
+}
+
+int main() {
+    // MSVC fails to use strucutred bindings in constexpr:
+    //
+    // error C2131: expression did not evaluate to a constant
+    // pfr/detail/functional.hpp(21): note: failure was caused by a read of a variable outside its lifetime
+#if !defined(_MSC_VER) || (_MSC_VER >= 1927) || !BOOST_PFR_USE_CPP17
+    test_constexpr_comparable<foo::comparable_struct>();
+
+    struct local_comparable_struct {
+        int i; short s; bool bl; int a,b,c,d,e,f;
+    };
+    test_constexpr_comparable<local_comparable_struct>();
+
+    struct local_comparable_struct_with_union {
+        int i; short s; bool bl; int a,b,c,d,e; test_union u;
+    };
+    test_constexpr_comparable<local_comparable_struct>();
+#endif
+    return boost::report_errors();
+}
+
+

test/core/run/core17_generated.cpp

@@ -0,0 +1,125 @@
+// Copyright (c) 2023 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/core.hpp>
+#include <type_traits> // for std::is_same
+
+struct A {
+    const volatile int cv_value = 0;
+    volatile int v_value = 0;
+    const int c_value = 0;
+    int value = 0;
+
+    const volatile int& cv_ref;
+    volatile int& v_ref;
+    const int& c_ref;
+    int& ref;
+
+    const volatile int&& cv_rref;
+    volatile int&& v_rref;
+    const int&& c_rref;
+    int&& rref;
+};
+
+int main() {
+#if BOOST_PFR_USE_CPP17
+    const volatile int cv_value = 0;
+    volatile int v_value = 0;
+    const int c_value = 0;
+    int value = 0;
+
+    typedef boost::pfr::detail::size_t_<12> fields_count_tag;
+
+    {
+        A a {cv_value, v_value, c_value, value,
+             cv_value, v_value, c_value, value,
+             std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        const A a {cv_value, v_value, c_value, value,
+                   cv_value, v_value, c_value, value,
+                   std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        volatile A a {cv_value, v_value, c_value, value,
+                      cv_value, v_value, c_value, value,
+                      std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        const volatile A a {cv_value, v_value, c_value, value,
+                            cv_value, v_value, c_value, value,
+                            std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+#endif
+}
+

test/core/run/destructuring_tie.cpp

@@ -1,14 +1,12 @@
 // Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2020 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/precise/core.hpp>
+#include <boost/pfr/core.hpp>
 #include <boost/core/lightweight_test.hpp>
 
-#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
-
 auto parseHex(char const* p, size_t limit = ~0u) {
     struct { size_t val; char const* rest; } res = { 0, p };
     while (limit) {
@@ -60,12 +58,3 @@ int main() {
     return boost::report_errors();
 }
 
-#else // C++14 without loophole
-
-#include <iostream>
-
-int main(int, char** argv) {
-   std::cerr << argv[0] << ": Not supported in C++14 without reflection loophole.\n";
-}
-
-#endif

test/core/run/error_pfr_c1202.cpp

@@ -1,14 +1,14 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-// Example from https://github.com/apolukhin/magic_get/issues/21
+// Example from https://github.com/boostorg/pfr/issues/21
 
 
 // boost::pfr::for_each_field crashes when sizeof(MyConfig) > 248 (probably >= 256)
 
-#include <boost/pfr/precise.hpp>
+#include <boost/pfr.hpp>
 
 #include <iostream>
 #include <type_traits>

test/core/run/fields_count_on_const.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2018 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

test/core/run/for_each_field.cpp

@@ -1,9 +1,9 @@
-// Copyright (c) 2016-2020 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/pfr/precise/core.hpp>
+#include <boost/pfr/core.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <sstream>
 
@@ -54,6 +54,8 @@ struct simple {
     short d;
 };
 
+struct empty{};
+
 
 int main () {
     std::size_t control = 0;
@@ -108,6 +110,13 @@ int main () {
         ss << val << ' ';
     });
     BOOST_TEST_EQ("42 a 3 ", ss.str());
+    ss.str("");
+
+    boost::pfr::for_each_field(empty{},  [&ss](auto&& val) {
+        ss << val << ' ';
+    });
+    BOOST_TEST_EQ("", ss.str());
+    ss.str("");
 
     return boost::report_errors();
 }