std::tuple like methods for user defined types without any macro or boilerplate code

Last update: Dec 23, 2022

Comments: 16

Boost.PFR

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 is a part of the Boost C++ Libraries. 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.

For a version of the library without boost:: namespace see PFR.

Test results

Branches	Build	Tests coverage	More info
Develop:			details...
Master:			details...

Latest developer documentation

Motivating Example #0

#include <iostream>
#include <fstream>
#include <string>

#include "boost/pfr.hpp"

struct some_person {
  std::string name;
  unsigned birth_year;
};

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!

  if (argc > 1) {
    std::ofstream ofs(argv[1]);
    ofs << boost::pfr::io(val);                       // File now contains: {"Edgar Allan Poe", 1809}
  }
}

Outputs:

Edgar Allan Poe was born in 1809

Motivating Example #1

#include <iostream>
#include "boost/pfr.hpp"

struct my_struct { // no ostream operator defined!
    int i;
    char c;
    double d;
};

int main() {
    my_struct s{100, 'H', 3.141593};
    std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
        << " fields: " << boost::pfr::io(s) << "\n";
}

Outputs:

my_struct has 3 fields: {100, H, 3.14159}

Motivating Example #2

#include <iostream>
#include "boost/pfr.hpp"

struct my_struct { // no ostream operator defined!
    std::string s;
    int i;
};

int main() {
    my_struct s{{"Das ist fantastisch!"}, 100};
    std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
        << " fields: " << boost::pfr::io(s) << "\n";
}

Outputs:

my_struct has 2 fields: {"Das ist fantastisch!", 100}

Requirements and Limitations

See docs.

License

Distributed under the Boost Software License, Version 1.0.

Owner

Boost.org

Boost provides free peer-reviewed portable C++ source libraries.

https://github.com/boostorg/pfr https://boost.org/libs/pfr

Comments

Manual type registering/structured bindings might be unnecessary

It occurred to me that it is possible to implement as_tuple in C++14 very easily using the visitor pattern, with the added benefit of supporting pointers, enums and non primitive types out of the box.

Following is a rough implementation of the idea, which outputs:

{42, a, 3.1, (nil), green, hello world!}

for

as_tuple(reg{42, 'a', 3.1, nullptr, color::green, "hello world!"}, [](auto&& t) {
    print_tuple(std::forward<decltype(t)>(t));
    std::cout << std::endl;
});

where

struct reg {
    int a;
    char b;
    double d;
    void* e;
    color f;
    std::string g;
};

and

enum class color {
    red,
    green,
    blue
};

std::ostream& operator <<(std::ostream& os, color c) {
    switch(c) {
        case color::red:
            os << "red";
            break;
        case color::green:
            os << "green";
            break;
        case color::blue:
            os << "blue";
            break;
    };

    return os;
}

Note: it only works on Clang + libc++ due to the reinterpret_cast to std::tuple.

#include <tuple>
#include <cstdint>
#include <utility>
#include <iostream>
#include <type_traits>
#include <initializer_list>

template<typename...>
using void_t = void;

template<typename>
struct type {};

template<std::size_t>
struct ubiq
{
    template<typename T>
    operator T() const;
};


template<typename, typename, typename = void>
struct _size_impl
{};

template<typename T, std::size_t head, std::size_t... tail>
struct _size_impl<T, std::index_sequence<head, tail...>,
    void_t<decltype(T{ubiq<head>{}, ubiq<tail>{}...})>
> :
    std::integral_constant<std::size_t, sizeof...(tail) + 1>
{};

template<typename T, std::size_t head, std::size_t... tail, typename _>
struct _size_impl<T, std::index_sequence<head, tail...>, _> :
    _size_impl<T, std::index_sequence<tail...>>
{};

template<typename T>
struct _size :
    _size_impl<T, std::make_index_sequence<sizeof(T)>>
{};

template<typename T>
using size = typename _size<T>::type;

template<typename F>
struct deducer
{
    F f;

    template<typename T>
    operator T() const {
        f(type<T>{});
        return {};
    }
};

template<typename F>
deducer<std::decay_t<F>> deduce(F&& f) {
    return {std::forward<F>(f)};
}

template<typename F, typename T, typename... Props>
auto as_tuple_impl(F&& f, T&& t, type<Props>...)
    -> std::enable_if_t<size<std::decay_t<T>>::value != sizeof...(Props)> {
    std::decay_t<T>{
        Props{}...,
        deduce(
            [&f, &t](auto prop) {
                as_tuple_impl(
                    std::forward<F>(f),
                    std::forward<T>(t),
                    type<Props>{}...,
                    prop
                );
            }
        )
    };
}

template<typename F, typename T, typename... Props>
auto as_tuple_impl(F&& f, T&& t, type<Props>...)
    -> std::enable_if_t<size<std::decay_t<T>>::value == sizeof...(Props)> {
    std::forward<F>(f)(reinterpret_cast<std::tuple<Props...>&&>(t));
}

template<typename F, typename T, typename... Props>
auto as_tuple_impl(F&& f, T& t, type<Props>...)
    -> std::enable_if_t<size<T>::value == sizeof...(Props)> {
    std::forward<F>(f)(reinterpret_cast<std::tuple<Props...>&>(t));
}

template<typename T, typename F>
auto as_tuple(T&& t, F&& f) {
    as_tuple_impl(std::forward<F>(f), std::forward<T>(t));
}

template<typename... R, std::size_t h, std::size_t... t>
void print_tuple_impl(std::tuple<R...> const& r, std::index_sequence<h, t...>) {
    std::cout << '{' << std::get<h>(r);
    std::initializer_list<int>{
        (void(std::cout << ", " << std::get<t>(r)), 0)...
    };
    std::cout << '}';
}

template<typename... T>
void print_tuple(std::tuple<T...> const& t) {
    print_tuple_impl(t, std::index_sequence_for<T...>{});
}

Attempt to factor out cast_to_layout_compatible

Hi,

Here's my attempt at implementing the idea I described in issue #12

I had some issues testing it -- even without my commit, I am on ubuntu 16.04 xenial and I don't have a c++14 standard library on my system, so I don't have some things like std::less<void> and std::greater<void> which are used in some of the tests.

However, the same set of tests are passing and failing before and after my commit, using gcc 5.4 and clang 4.0, nor do I have new warnings. So I think this commit is at least close to correct.

(As a minor complaint -- it would be nice if there were a simple script to run the tests. To figure out how to run them locally I had to sort of reverse engineer from the travis.yml file. I guess that the test mechanism relies on the boost repo and so can't be run without cloning boost.)

I would like to test also on my macbook, and I would also like to do some tests with godbolt to inspect the generated assembly and make sure this is not significantly different in terms of efficiency.

However, I don't have time to do that stuff until about Thursday, so you might want to hold off until then. I will try to test it with c++14 conforming standard library at that time.

The commit message describes the changes I made. Basically, where previously we used cast_to_layout_compatible and then make_tuple_of_references, what I tried to do was, generalize make_tuple_of_references so that it takes instead an arbitrary object, together with a getter that can implement get<i> on that object.

Then, for cases when you needed to apply this to a tuple, there is a sequence_tuple_getter which wraps sequence_tuple::get. And for user-defined structures, there is an offset_based_getter, which takes as template parameters the user-structure S, and the sequence_tuple<T1, T2, ...> generated by using the ubiqs. Assuming that the sequence_tuple is indeed layout compatible with S, the offset_based_getter I believe should optimize to code that is just as good as cast_to_layout_compatible, and I don't think it should violate the standard anywhere. There is some more technical discussion in the commit message.

Another thing to be considered, now that I think of it, is that maybe the cast_to_layout_compatible should be kept around and enabled by use of a flag -- that way if on some compilers this change causes a regression, people can revert to the old way.

Cheers, Chris

Example does not compile VS C++17

The example:

#include <iostream>
#include <string>
#include "boost/pfr/precise.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!
}

Does not compile:

1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\fields_count.hpp(209): error C2338: ====================> Boost.PFR: Types with user specified constructors (non-aggregate initializable types) are not supported.
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\core17_generated.hpp(1036): note: see reference to function template instantiation 'size_t boost::pfr::detail::fields_count<T>(void) noexcept' being compiled
1>        with
1>        [
1>            T=some_person
1>        ]
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\precise\core.hpp(50): note: see reference to function template instantiation 'auto boost::pfr::detail::tie_as_tuple<T>(T &) noexcept' being compiled
1>        with
1>        [
1>            T=some_person
1>        ]
1>a:\cpp\reftest\reftest\src\main.cpp(62): note: see reference to function template instantiation 'decltype(auto) boost::pfr::get<0,some_person>(T &) noexcept' being compiled
1>        with
1>        [
1>            T=some_person
1>        ]
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\fields_count.hpp(214): error C2338: ====================> Boost.PFR: If there's no other failed static asserts then something went wrong. Please report this issue to the github along with the structure you're reflecting.
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\sequence_tuple.hpp(114): error C2338: ====================> Boost.PFR: Tuple index out of bounds
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\precise\core.hpp(50): note: see reference to function template instantiation 'decltype(auto) boost::pfr::detail::sequence_tuple::get<0,>(boost::pfr::detail::sequence_tuple::tuple<> &&) noexcept' being compiled
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\sequence_tuple.hpp(115): error C2672: 'get_impl': no matching overloaded function found
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\sequence_tuple.hpp(113): error C2784: 'T &boost::pfr::detail::sequence_tuple::get_impl(boost::pfr::detail::sequence_tuple::base_from_member<N,T> &) noexcept': could not deduce template argument for 'boost::pfr::detail::sequence_tuple::base_from_member<0,T> &' from 'boost::pfr::detail::sequence_tuple::tuple<>'
1>a:\cpp\reftest\reftest\ext\include\boost\pfr\detail\sequence_tuple.hpp(51): note: see declaration of 'boost::pfr::detail::sequence_tuple::get_impl'
1>a:\cpp\reftest\reftest\src\main.cpp(62): error C2679: binary '<<': no operator found which takes a right-hand operand of type 'void' (or there is no acceptable conversion)

Compiler:

/JMC /permissive- /MP /GS /W3 /Zc:wchar_t /I"A:\cpp\reftest\reftest\ext\include\" /I"A:\cpp\reftest\\include\" /I"C:\Program Files (x86)\Visual Leak Detector\include" /ZI /Gm- /Od /sdl /Fd"x64\Debug\vc141.pdb" /Zc:inline /fp:precise /D "_MBCS" /errorReport:prompt /WX- /Zc:forScope /RTC1 /Gd /MDd /std:c++17 /FC /Fa"x64\Debug\" /EHsc /nologo /Fo"x64\Debug\" /Fp"x64\Debug\reftest.pch" /diagnostics:classic

pfr::ops doesn't support unions in PODs

First off, I love this library. I find myself writing a lot of binary protocols that support unions. One thing I do to test out my binary parsers/generators, is just sending the instance to operator<< and not having to write a 100+ line function myself, I love this (ehm, Rust has this as well).

Any ideas on how you could support unions? Maybe just convert to std::tuple<> and print that? I've gotten boost::hana to play nice sometimes but nothing notable. I think if you support unions, lots of C code or legacy C++ could be brought to a new light by just automatically having pfr::ops work.

Thanks!
C1202 on MSVC, probably on every sizeof(T) >= 256 class

your library is superb! Having that kind of "reflection light" is handy in so many places!

I was going to make an experimental Config class, which can be reflected for Serialization to file or visualisation etc. At some point my MSVC compiler reports error C1202 when trying to call pfr::for_each_field on that class object. After some investigation it seems to appear when the reflected class reaches 256 Bytes. I.e. I can get this error by either adding more members or by increasing the size of each member.

The attached example has 2 defines, if you set one of them, MSVC (VS2017 15.6.2) will emit C1202. I hope I didn´t make an error, since I´m not sure if my Cfg Templates do actually fit the requirements. I´m afraid its a compiler limitation w/o workarround... All I can tell is, if it compiles it works as expected. If you are interested to look into this and need more info please let me know. Thanks!

pfr_C1202.zip
CMake support

At the moment this library does not support clients using CMake. Is there a plan to change that?

The documentation's You can just copy the content of the "include" folder suggestion is not acceptable.

Since this is a header-only library with no dependency on other Boost libraries, the lists file to provide support would look trivial.
I could make a PR adding a lists file if desired.

compiler errors with gcc-7 and clang-4

Tried to build the "Motivating Example"s.

C++14 example was okay with gcc-6. C++14 example and C++17 example did not compile with gcc-7 and clang-4.

Note: gcc (Ubuntu 7-20170407-0ubuntu2) 7.0.1 20170407 (experimental) [trunk revision 246759] clang version 4.0.0-1ubuntu1 (tags/RELEASE_400/rc1)

C++14 example compiler errors (gcc 7):

gcc.compile.c++ bin/gcc-7/release/source/test_magic.o
In file included from /home/mike/workspace/magic_get/include/boost/pfr/detail/core17.hpp:11:0,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise/core.hpp:20,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise.hpp:12,
                 from /home/mike/workspace/magic_get/include/boost/pfr.hpp:12,
                 from source/test_magic.cpp:9:
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp: In instantiation of ‘constexpr auto boost::pfr::detail::as_tuple_impl(T&&, boost::pfr::detail::size_t_<3>) [with T = const my_struct&; boost::pfr::detail::size_t_<3> = std::integral_constant<long unsigned int, 3>]’:
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:1032:43:   required from ‘constexpr auto boost::pfr::detail::as_tuple(const T&) [with T = my_struct]’
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp:45:69:   required from ‘void boost::pfr::write(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct]’
/home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:129:26:   required from ‘boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> boost::pfr::ops::operator<<(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct; boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> = std::basic_ostream<char>&]’
source/test_magic.cpp:22:27:   required from here
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:57:9: error: ‘std::tuple_size<const my_struct>::value’ is not an integral constant expression
   auto& [a,b,c] = std::forward<T>(val);
         ^~~~~~~
In file included from /home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:15:0,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise.hpp:14,
                 from /home/mike/workspace/magic_get/include/boost/pfr.hpp:12,
                 from source/test_magic.cpp:9:
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp: In instantiation of ‘void boost::pfr::write(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct]’:
/home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:129:26:   required from ‘boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> boost::pfr::ops::operator<<(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct; boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> = std::basic_ostream<char>&]’
source/test_magic.cpp:22:27:   required from here
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp:45:47: error: invalid use of void expression
     detail::print_impl<0, fields_count>::print(out, detail::as_tuple(value));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    "g++"  -ftemplate-depth-128 -march=native -ftemplate-depth=256 -std=c++17 -O3 -finline-functions -Wno-inline -Wall -fPIC  -DBOOST_ALL_DYN_LINK -DNDEBUG  -I"/home/mike/workspace/magic_get/include" -I"include" -c -o "bin/gcc-7/release/source/test_magic.o" "source/test_magic.cpp"

...failed gcc.compile.c++ bin/gcc-7/release/source/test_magic.o...

C++17 example compiler errors (gcc-7):

gcc.compile.c++ bin/gcc-7/release/source/test_magic.o
In file included from /home/mike/workspace/magic_get/include/boost/pfr/detail/core17.hpp:11:0,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise/core.hpp:20,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise.hpp:12,
                 from /home/mike/workspace/magic_get/include/boost/pfr.hpp:12,
                 from source/test_magic.cpp:9:
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp: In instantiation of ‘constexpr auto boost::pfr::detail::as_tuple_impl(T&&, boost::pfr::detail::size_t_<2>) [with T = const my_struct&; boost::pfr::detail::size_t_<2> = std::integral_constant<long unsigned int, 2>]’:
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:1032:43:   required from ‘constexpr auto boost::pfr::detail::as_tuple(const T&) [with T = my_struct]’
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp:45:69:   required from ‘void boost::pfr::write(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct]’
/home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:129:26:   required from ‘boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> boost::pfr::ops::operator<<(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct; boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> = std::basic_ostream<char>&]’
source/test_magic.cpp:21:27:   required from here
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:51:9: error: ‘std::tuple_size<const my_struct>::value’ is not an integral constant expression
   auto& [a,b] = std::forward<T>(val);
         ^~~~~
In file included from /home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:15:0,
                 from /home/mike/workspace/magic_get/include/boost/pfr/precise.hpp:14,
                 from /home/mike/workspace/magic_get/include/boost/pfr.hpp:12,
                 from source/test_magic.cpp:9:
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp: In instantiation of ‘void boost::pfr::write(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct]’:
/home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:129:26:   required from ‘boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> boost::pfr::ops::operator<<(std::basic_ostream<_CharT, _Traits>&, const T&) [with Char = char; Traits = std::char_traits<char>; T = my_struct; boost::pfr::detail::enable_not_ostreamable_t<std::basic_ostream<_CharT, _Traits>, T> = std::basic_ostream<char>&]’
source/test_magic.cpp:21:27:   required from here
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp:45:47: error: invalid use of void expression
     detail::print_impl<0, fields_count>::print(out, detail::as_tuple(value));
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    "g++"  -ftemplate-depth-128 -march=native -ftemplate-depth=256 -std=c++17 -O3 -finline-functions -Wno-inline -Wall -fPIC  -DBOOST_ALL_DYN_LINK -DNDEBUG  -I"/home/mike/workspace/magic_get/include" -I"include" -c -o "bin/gcc-7/release/source/test_magic.o" "source/test_magic.cpp"

...failed gcc.compile.c++ bin/gcc-7/release/source/test_magic.o...

C++17 example compiler errors (clang-4):

clang-linux.compile.c++.without-pth bin/clang-linux-4.0.0/release/source/test_magic.o
In file included from source/test_magic.cpp:9:
In file included from /home/mike/workspace/magic_get/include/boost/pfr.hpp:12:
In file included from /home/mike/workspace/magic_get/include/boost/pfr/precise.hpp:12:
In file included from /home/mike/workspace/magic_get/include/boost/pfr/precise/core.hpp:20:
In file included from /home/mike/workspace/magic_get/include/boost/pfr/detail/core17.hpp:11:
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:51:9: error: cannot decompose this type; 'std::tuple_size<const my_struct>::value' is not a valid integral constant expression
  auto& [a,b] = std::forward<T>(val);
        ^
/home/mike/workspace/magic_get/include/boost/pfr/detail/core17_generated.hpp:1032:30: note: in instantiation of function template specialization 'boost::pfr::detail::as_tuple_impl<const my_struct &>' requested here
  return boost::pfr::detail::as_tuple_impl(val, fields_count_tag{});
                             ^
/home/mike/workspace/magic_get/include/boost/pfr/precise/io.hpp:45:61: note: in instantiation of function template specialization 'boost::pfr::detail::as_tuple<my_struct>' requested here
    detail::print_impl<0, fields_count>::print(out, detail::as_tuple(value));
                                                            ^
/home/mike/workspace/magic_get/include/boost/pfr/precise/ops.hpp:129:21: note: in instantiation of function template specialization 'boost::pfr::write<char, std::char_traits<char>, my_struct>' requested here
        boost::pfr::write(out, value);
                    ^
source/test_magic.cpp:21:24: note: in instantiation of function template specialization 'boost::pfr::ops::operator<<<char, std::char_traits<char>, my_struct>' requested here
        << " fields: " << s << "\n";
                       ^
4 errors generated.

  "clang++" -c -x c++ -march=native -std=c++1z -O3 -Wno-inline -Wall -fPIC  -DBOOST_ALL_DYN_LINK -DNDEBUG -I"/home/mike/workspace/magic_get/include" -I"include" -o "bin/clang-linux-4.0.0/release/source/test_magic.o" "source/test_magic.cpp"

...failed clang-linux.compile.c++.without-pth bin/clang-linux-4.0.0/release/source/test_magic.o...

Reopen #27

Issue #27 should have been fixed in latest master but it doesn't.

Compiling

#include <memory>
#include <boost/pfr.hpp>

struct Message {
  std::unique_ptr<int> data;
};

int main(int argc, char* argv[]) {
  Message message;
  auto& ptr = boost::pfr::get<0>(message);
  return 0;
}

gives me

In file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14.hpp:13:0,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:23,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr.hpp:12,
                 from /tmp/untitled/main.cpp:2:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp: In instantiation of ‘struct boost::pfr::detail::loophole_type_list<Message, std::integer_sequence<unsigned int, 0u> >’:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:108:72:   required from ‘auto boost::pfr::detail::tie_as_tuple_loophole_impl(T&) [with T = Message]’
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:199:58:   required from ‘auto boost::pfr::detail::tie_as_tuple(T&) [with T = Message]’
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:50:64:   required from ‘constexpr decltype(auto) boost::pfr::get(T&) [with unsigned int I = 0u; T = Message]’
/tmp/untitled/main.cpp:10:41:   required from here
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:98:68: error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int; _Dp = std::default_delete<int>]’
     : sequence_tuple::tuple< decltype(T{ loophole_ubiq<T, I>{}... }, 0) >
                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
In file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/c++/6.3.0/memory:81:0,
                 from /tmp/untitled/main.cpp:1:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/c++/6.3.0/bits/unique_ptr.h:359:7: note: declared here
       unique_ptr(const unique_ptr&) = delete;
       ^~~~~~~~~~
In file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14.hpp:13:0,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:23,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr.hpp:12,
                 from /tmp/untitled/main.cpp:2:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:87:15: note:   after user-defined conversion: constexpr boost::pfr::detail::loophole_ubiq<T, N>::operator U&() const [with U = std::unique_ptr<int>; unsigned int <anonymous> = 1u; T = Message; unsigned int N = 0u]
     constexpr operator U&() const noexcept; // `const` here helps to avoid ambiguity in loophole instantiations. optional_like test validate that behavior.
               ^~~~~~~~
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:100:58: error: use of ‘auto boost::pfr::detail::loophole(boost::pfr::detail::tag<Message, 0u>)’ before deduction of ‘auto’
     using type = sequence_tuple::tuple< decltype(loophole(tag<T, I>{}))... >;
                                                  ~~~~~~~~^~~~~~~~~~~~~
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:100:58: error: use of ‘auto boost::pfr::detail::loophole(boost::pfr::detail::tag<Message, 0u>)’ before deduction of ‘auto’
In file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise.hpp:12:0,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr.hpp:12,
                 from /tmp/untitled/main.cpp:2:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp: In instantiation of ‘constexpr decltype(auto) boost::pfr::get(T&) [with unsigned int I = 0u; T = Message]’:
/tmp/untitled/main.cpp:10:41:   required from here
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:50:42: error: invalid use of void expression
     return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/tmp/untitled/main.cpp: In function ‘int main(int, char**)’:
/tmp/untitled/main.cpp:10:41: error: forming reference to void
   auto& ptr = boost::pfr::get<0>(message);
                                         ^
make[2]: *** [CMakeFiles/untitled.dir/main.cpp.o] Error 1
make[1]: *** [CMakeFiles/untitled.dir/all] Error 2

Is there some way to get the fields by name?

magic_get is really magic, however magic_get can only get fileds by index, sometimes i need get fields by name, is there some way to get the fields by name?
Interfaces core.hpp and tuple_size.hpp no more has aliases

In C++ we can't make specialization for type alias, but for structure can. This PR will make https://github.com/boostorg/pfr/issues/100 possible to implement.

Support std::optional<>

It seems that std::experimental::optional (c++14) or std::optional(c++17) are not supported

n file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:29:0,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14.hpp:13,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:24,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/BaseValueHandlers.h:6,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/StdValueHandlers.h:4,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/UserParser.h:4,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/SystemFunctionParser.h:10,
                 from /home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.h:5,
                 from /home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.cpp:1:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/offset_based_getter.hpp: In instantiation of ‘class boost::pfr::detail::offset_based_getter<ipconnector::Temp, boost::pfr::detail::sequence_tuple::tuple<int, int> >’:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:154:61:   required from ‘auto boost::pfr::detail::tie_as_tuple_loophole_impl(T&) [with T = ipconnector::Temp]’
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:255:55:   required from ‘void boost::pfr::detail::for_each_field_dispatcher(T&, F&&, std::index_sequence<I ...>) [with T = ipconnector::Temp; F = boost::pfr::for_each_field(T&&, F&&) [with T = ipconnector::Temp&; F = ipconnector::SFClientIPC::ModifyScene(const VimarIPCParser::SystemFunctionParser::ModifySceneRequest&)::<lambda(const auto:9&)>]::<lambda(auto:1&&)>; unsigned int ...I = {0u, 1u}; std::index_sequence<I ...> = std::integer_sequence<unsigned int, 0u, 1u>]’
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:140:52:   required from ‘void boost::pfr::for_each_field(T&&, F&&) [with T = ipconnector::Temp&; F = ipconnector::SFClientIPC::ModifyScene(const VimarIPCParser::SystemFunctionParser::ModifySceneRequest&)::<lambda(const auto:9&)>]’
/home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.cpp:117:56:   required from here
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/offset_based_getter.hpp:63:3: error: static assertion failed: ====================> 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!");
   ^~~~~~~~~~~~~
In file included from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14.hpp:13:0,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:24,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr.hpp:12,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/BaseValueHandlers.h:6,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/StdValueHandlers.h:4,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/UserParser.h:4,
                 from /opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/LibVimarIPCParser/SystemFunctionParser.h:10,
                 from /home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.h:5,
                 from /home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.cpp:1:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp: In instantiation of ‘void boost::pfr::detail::for_each_field_dispatcher(T&, F&&, std::index_sequence<I ...>) [with T = ipconnector::Temp; F = boost::pfr::for_each_field(T&&, F&&) [with T = ipconnector::Temp&; F = ipconnector::SFClientIPC::ModifyScene(const VimarIPCParser::SystemFunctionParser::ModifySceneRequest&)::<lambda(const auto:9&)>]::<lambda(auto:1&&)>; unsigned int ...I = {0u, 1u}; std::index_sequence<I ...> = std::integer_sequence<unsigned int, 0u, 1u>]’:
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/precise/core.hpp:140:52:   required from ‘void boost::pfr::for_each_field(T&&, F&&) [with T = ipconnector::Temp&; F = ipconnector::SFClientIPC::ModifyScene(const VimarIPCParser::SystemFunctionParser::ModifySceneRequest&)::<lambda(const auto:9&)>]’
/home/cucchetf/workspace/p378_ipconnectorserver/src/ipc/SFClientIPC.cpp:117:56:   required from here
/opt/vrag/releases/private/cucchetf-vimar-agx-dbg-latest/sdk/sysroots/cortexa9hf-neon-poky-linux-gnueabi/usr/include/boost/pfr/detail/core14_loophole.hpp:254:23: error: use of ‘boost::pfr::for_each_field(T&&, F&&)::<lambda(auto:1&&)> mutable [with auto:1 = boost::pfr::detail::sequence_tuple::tuple<int&, int&>; T = ipconnector::Temp&; F = ipconnector::SFClientIPC::ModifyScene(const VimarIPCParser::SystemFunctionParser::ModifySceneRequest&)::<lambda(const auto:9&)>]’ before deduction of ‘auto’
     std::forward<F>(f)(
     ~~~~~~~~~~~~~~~~~~^
         boost::pfr::detail::tie_as_tuple_loophole_impl(t)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     );
     ~

boost:pfr::io insertion into std::cout works, but std::stringstream does not?

https://cppcoach.godbolt.org/z/Mocb7znYf

Only only does it not allow to stream into std::ostream / std::stringstream but also makes it "not play nice with {fmt}". see https://github.com/fmtlib/fmt/issues/3245

in the meantime, how do I work around this?

tuple_size_v fails with optional> field in the structure

This code fails to compile with both clang and gcc trunk (but compiles with the latest MSVC):

#include <memory>
#include <optional>

#include <boost/pfr/core.hpp>

struct optional_linked_list
{
	int value;
	std::optional<std::unique_ptr<optional_linked_list>> next;
};

int main()
{
    return boost::pfr::tuple_size_v<optional_linked_list>;
}

Also see https://godbolt.org/z/1d9W5e4b3 (tested with Boost 1.80.0).

This is the clang-trunk compile error:

In file included from <source>:4:
In file included from /opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/core.hpp:12:
In file included from /opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/detail/core.hpp:17:
In file included from /opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/detail/core17.hpp:11:
In file included from /opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/detail/fields_count.hpp:13:
/opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/detail/unsafe_declval.hpp:29:12: error: static_cast from 'typename std::remove_reference<unique_ptr<optional_linked_list>>::type' (aka 'std::unique_ptr<optional_linked_list>') to 'std::unique_ptr<optional_linked_list>' uses deleted function
    return static_cast<T>(*ptr);
           ^~~~~~~~~~~~~~~~~~~~
/opt/compiler-explorer/libs/boost_1_80_0/boost/pfr/detail/fields_count.hpp:45:24: note: in instantiation of function template specialization 'boost::pfr::detail::unsafe_declval<std::unique_ptr<optional_linked_list>>' requested here
        return detail::unsafe_declval<Type>();
                       ^
/opt/compiler-explorer/gcc-snapshot/lib/gcc/x86_64-linux-gnu/13.0.0/../../../../include/c++/13.0.0/optional:244:17: note: in instantiation of function template specialization 'boost::pfr::detail::ubiq_rref_constructor::operator unique_ptr<std::unique_ptr<optional_linked_list>>' requested here
            : _M_value(std::forward<_Args>(__args)...)
                       ^
/opt/compiler-explorer/gcc-snapshot/lib/gcc/x86_64-linux-gnu/13.0.0/../../../../include/c++/13.0.0/bits/unique_ptr.h:523:7: note: candidate constructor has been explicitly deleted
      unique_ptr(const unique_ptr&) = delete;
      ^

Difference between `boost::pfr::tuple_element` and `std::tuple_element`

https://godbolt.org/z/4odnsoKzK I know that PFR dont work with const or reference fields. But why don't we remove this restriction in C++17 mode? I suppose that structured binding already has all that we need to do it: https://godbolt.org/z/YbnTevjo5
A small difference between `boost::pfr::get` and `std::get`

As we know, std::get overloads for a std::tuple can't return values, it always returns a reference(https://en.cppreference.com/w/cpp/utility/tuple/get). This library shows itself as "tuple-like interface" and i suppose that boost::pfr::get must be fit to std::get in every detail. But i find that boost::pfr::get in some cases can return a value, and make a copy: https://godbolt.org/z/1GWaqsah4 Can we fix it? Or is it better not to touch it, to prevent a breaking change?
Make pfr more friendly for integrating into other libraries?
Description of issue Now i'm working with Boost.Fusion extension for Boost.PFR, i decomposed it into 3 PR's and opened these PR's here: https://github.com/boostorg/fusion/pull/241, here https://github.com/boostorg/fusion/pull/242 and here https://github.com/boostorg/fusion/pull/243. Review is moving on, there is some wishes from reviewers(more on that later). First, I would like to talk about such a problem like 3 PR's is too much code and the review takes too long. I suggest to make pfr more adaptable and more friendly to adapt into other libraries(not only fusion).

Suggested solution

To implement two functions:

boost::pfr::view

boost::pfr::view_fields

To implement BOOST_PFR_REGISTRATE_REFLECTABLE macro.

To add boost::pfr::is_reflectable trait. Example of using trait:

struct A {}; struct B {}; struct C {}; BOOST_PFR_REGISTRATE_REFLECTABLE(A) using boost::pfr::is_reflectable; is_reflectable<A>::value; //< true is_reflectable<decltype(boost::pfr::view_fields(B{}))>::value; //< true is_reflectable<C>::value; //< false

To use boost::pfr::is_reflectable trait for create overloading of compare/io operators and specialization of std::hash function. Examples of using these overloads:

#include <boost/pfr/ops.hpp> template <class T> struct uniform_comparator_less { bool operator()(const T& lhs, const T& rhs) const noexcept { // If T has operator< or conversion operator then it is used. return boost::pfr::view(lhs) < boost::pfr::view(rhs); } };

#include <boost/pfr/functions_for.hpp> struct pair_like { int first; short second; }; BOOST_PFR_REGISTRATE_REFLECTABLE(pair_like) // Added pair_like's specialization for is_reflectable trait. // ... assert(pair_like{1, 2} < pair_like{1, 3});

#include <boost/pfr/io_fields.hpp> struct pair_like { int first; std::string second; }; inline std::ostream& operator<<(std::ostream& os, const pair_like& x) { return os << bost::pfr::view_fields(x); }

To declare io, eq, ne, lt, gt, le, ge, hash_value, io_fields, eq_fields, ne_fields, lt_fields, gt_fields, le_fields, ge_fields, hash_fields, BOOST_PFR_FUNCTIONS_FOR as deprecated, and to actualize https://www.boost.org/doc/libs/1_75_0/doc/html/boost_pfr/tutorial.html#boost_pfr.tutorial.three_ways_of_getting_operators.

Conclusion If everything planned can be done, then the PFR will be adapted as easily as the std::tuple, it will be just one small PR.

std::tuple like methods for user defined types without any macro or boilerplate code

Boost.PFR

Test results

Motivating Example #0

Motivating Example #1

Motivating Example #2

Requirements and Limitations

License

Owner

Boost.org

Comments

Manual type registering/structured bindings might be unnecessary

Attempt to factor out cast_to_layout_compatible

Example does not compile VS C++17

pfr::ops doesn't support unions in PODs

C1202 on MSVC, probably on every sizeof(T) >= 256 class

CMake support

compiler errors with gcc-7 and clang-4

Reopen #27

Is there some way to get the fields by name?

Interfaces core.hpp and tuple_size.hpp no more has aliases

Support std::optional<>

boost:pfr::io insertion into std::cout works, but std::stringstream does not?

tuple_size_v fails with optional> field in the structure

Difference between `boost::pfr::tuple_element` and `std::tuple_element`

A small difference between `boost::pfr::get` and `std::get`

Make pfr more friendly for integrating into other libraries?

Related tags

Gesture-Detecting-Macro-Keyboard - Glorified Bluetooth macro keyboard with machine learning (TensorFlow Lite for Microcontrollers) running on an ESP32.

WTD is a python tool for replacing values with the C preprocessor macro which defined them.

Tuple but with tags.

Arbitrary Precision provides C++ long integer types that behave as basic integer types. This library aims to be intuitive and versatile in usage, rather than fast.

Invoke.hpp - std::invoke/std::apply analogs for C++11/14

Loads a signed kernel driver which allows you to map any driver to kernel mode without any traces of the signed / mapped driver.

Automatically load dlls into any executables without replacing any files!

A C++14 macro to get the type of the current class without naming it

Cobalt Strike User-Defined Reflective Loader written in Assembly & C for advanced evasion capabilities.

Generalized easy to use SPI library for Arduino designed mainly for immense data transfer through multiple slaves. This library features Cyclic Redundancy Check (CRC) and user defined data transfer which inspired by Nick Gammon.

My_Shell is a user-deﬁned interactive shell written in C that works similar to the original shell in linux

BokuLoader - Cobalt Strike User-Defined Reflective Loader written in Assembly & C for advanced evasion capabilities.

ToPS is an objected-oriented framework implemented using C++ that facilitates the integration of probabilistic models for sequences over a user defined alphabet

A light-weight Flutter Engine Embedder based on HADK ,which for Android devices that runs without any java code

32blit SDK boilerplate for the PicoSystem RP2040-based handheld

ESP32 + GitHub Actions + Husarnet. A boilerplate project for ESP32 allowing in-field firmware update using GitHub Actions workflow.

Boilerplate-free YAML parsing for C++

Boilerplate to create a project with: STM32 + Ethernet + micro-ROS + FreeRTOS + Arduino + PlatformIO

Poc to test my little friend features without any sdk