Метапрограммирование в C++ и русская литература: через страдания к просветлению

my_variant<int, char, std::string> val("Hello World!");

#define variant_TL1( T1 ) detail::typelist< T1, detail::nulltype >
#define variant_TL2( T1, T2) detail::typelist< T1, variant_TL1( T2) >
#define variant_TL3( T1, T2, T3) detail::typelist< T1, variant_TL2( T2, T3) >
#define variant_TL4( T1, T2, T3, T4) detail::typelist< T1, variant_TL3( T2, T3, T4) >
#define variant_TL5( T1, T2, T3, T4, T5) detail::typelist< T1, variant_TL4( T2, T3, T4, T5) >
#define variant_TL6( T1, T2, T3, T4, T5, T6) detail::typelist< T1, variant_TL5( T2, T3, T4, T5, T6) >
#define variant_TL7( T1, T2, T3, T4, T5, T6, T7) detail::typelist< T1, variant_TL6( T2, T3, T4, T5, T6, T7) >
#define variant_TL8( T1, T2, T3, T4, T5, T6, T7, T8) detail::typelist< T1, variant_TL7( T2, T3, T4, T5, T6, T7, T8) >
#define variant_TL9( T1, T2, T3, T4, T5, T6, T7, T8, T9) detail::typelist< T1, variant_TL8( T2, T3, T4, T5, T6, T7, T8, T9) >
#define variant_TL10( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) detail::typelist< T1, variant_TL9( T2, T3, T4, T5, T6, T7, T8, T9, T10) >
#define variant_TL11( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) detail::typelist< T1, variant_TL10( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
#define variant_TL12( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) detail::typelist< T1, variant_TL11( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) >
#define variant_TL13( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) detail::typelist< T1, variant_TL12( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) >
#define variant_TL14( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) detail::typelist< T1, variant_TL13( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) >
#define variant_TL15( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) detail::typelist< T1, variant_TL14( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) >
#define variant_TL16( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) detail::typelist< T1, variant_TL15( T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) >

# /* Property-holder class property presence checker */
#
# define HAS_PROPERTY_PROPERTY_IMPL_GENERIC(ClassName, PI) \
else if (name == BOOST_PP_STRINGIZE(PROP_NAME(PI))) {return true;}
# define HAS_PROPERTY_PROPERTY(_, ClassName, PI)\
BOOST_PP_CAT(HAS_PROPERTY_PROPERTY_IMPL_, PROP_KIND(PI))(ClassName, PI)
# define PROPERTIES__DO_HAS_PROPERTY(ClassName, S) \
BOOST_PP_SEQ_FOR_EACH(HAS_PROPERTY_PROPERTY, ClassName, S)
# define MAKE_BASE_HAS_PROPERTY_CALL(ClassName, BaseClassName) \
return static_cast<BaseClassName const*>(m_Host)->properties__.has_property(name);

template< size_t NumVars, typename Visitor, typename ... V >
struct VisitorImpl
{
    typedef decltype(std::declval<Visitor>()(get<0>(static_cast<const V&>(std::declval<V>()))...)) result_type;
    typedef VisitorApplicator<result_type> applicator_type;
};
} // detail
// No perfect forwarding here in order to simplify code
template< typename Visitor, typename ... V >
inline auto visit(Visitor const& v, V const& ... vars) -> typename detail::VisitorImpl<sizeof ... (V), Visitor, V... > ::result_type
{
    typedef detail::VisitorImpl<sizeof ... (V), Visitor, V... > impl_type;
    return impl_type::applicator_type::apply(v, vars...);
}

vector<int, char, std::string> stuff(1, 'x', "howdy");
struct print_xml
{
    template <typename T>
    void operator()(T const& x) const
    {
        std::cout
            << '<' << typeid(x).name() << '>'
            << x
            << "</" << typeid(x).name() << '>'
            ;
    }
};
for_each(stuff, print_xml());

// 1. Give introspection capabilities to 'Person'
struct Person {
  BOOST_HANA_DEFINE_STRUCT(Person,
    (std::string, name),
    (int, age)
  );
};
// 2. Write a generic serializer (bear with std::ostream for the example)
auto serialize = [](std::ostream& os, auto const& object) {
  hana::for_each(hana::members(object), [&](auto member) {
    os << member << std::endl;
  });
};
// 3. Use it
Person john{"John", 30};
serialize(std::cout, john);

struct [[serializable]] Person {
    std::string name;
    int age;
};
template<typename Class>
auto serialize(std::ostream& os, Class&& object) -> std::enable_if_t<
        tinyrefl::has_metadata<std::decay_t<Class>>() &&
        tinyrefl::has_attribute<std::decay_t<Class>>("interesting"),
    std::ostream&>
{
    tinyrefl::visit_member_variables(object, [&os](const auto& /* name */, const auto& var) {
        os << var << std::endl;
    });
    return equal;
}

out::BracedStreamScope flNs("\nnamespace flex_lib", "\n\n", 0);
hdrOs << out::new_line(1) << flNs;
for (reflection::EnumInfoPtr enumInfo : enums)
{
    auto scopedParams = MakeScopedParams(hdrOs, enumInfo);
    {
        hdrOs << out::new_line(1) << "template<>";
        out::BracedStreamScope body("inline const char* Enum2String($enumFullQualifiedName$ e)", "\n");
        hdrOs << out::new_line(1) << body;
        hdrOs << out::new_line(1) << "return $namespaceQual$::$enumName$ToString(e);";
    }
    {
        hdrOs << out::new_line(1) << "template<>";
        out::BracedStreamScope body("inline $enumFullQualifiedName$ String2Enum<$enumFullQualifiedName$>(const char* itemName)", "\n");
        hdrOs << out::new_line(1) << body;
        hdrOs << out::new_line(1) << "return $namespaceQual$::StringTo$enumName$(itemName);";
    }
}

inline const char* {{enumName}}ToString({{scopedName}} e)
{
    switch (e)
    {
    {% for itemName in enum.items | map(attribute="itemName") | sort%}
    case {{prefix}}{{itemName}}:
        return "{{itemName}}";
    {% endfor %}
    }
    return "Unknown Item";
}

#define FL_MAKE_STRING_ENUM_NAME(Entry) Entry
#define FL_MAKE_WSTRING_ENUM_NAME(Entry) L ## Entry
#define FL_DECLARE_ENUM2STRING_ENTRY_IMPL(STRING_EXPANDER, EntryId, EntryName) \
        case EntryId: \
                result = STRING_EXPANDER(EntryName); \
                break;
#define FL_DECLARE_STRING2ENUM_ENTRY_IMPL(STRING_EXPANDER, EntryId, EntryName) result[STRING_EXPANDER(EntryName)] = EntryId;
#define FL_DECLARE_ENUM2STRING_ENTRY(_, STRING_EXPANDER, Entry) FL_DECLARE_ENUM2STRING_ENTRY_IMPL(STRING_EXPANDER, BOOST_PP_TUPLE_ELEM(3, 0, Entry), BOOST_PP_TUPLE_ELEM(3, 2, Entry))
#define FL_DECLARE_STRING2ENUM_ENTRY(_, STRING_EXPANDER, Entry) FL_DECLARE_STRING2ENUM_ENTRY_IMPL(STRING_EXPANDER, BOOST_PP_TUPLE_ELEM(3, 0, Entry), BOOST_PP_TUPLE_ELEM(3, 2, Entry))
        
#define FL_DECLARE_ENUM_STRINGS(EnumName, MACRO_NAME, S) \
inline EnumName ## _StringMap_CharType const* EnumName##ToString(EnumName e) \
{ \
    EnumName ## _StringMap_CharType const* result = NULL; \
    switch (e) \
    { \
        BOOST_PP_SEQ_FOR_EACH(FL_DECLARE_ENUM2STRING_ENTRY, MACRO_NAME, S) \
    } \
                \
    return result; \
}

struct ObjectInjector : boost::static_visitor<>
{
public:
    ObjectInjector(ClassInfoPtr targetClass, reflection::AccessType accessType)
        : m_target(targetClass)
        , m_accessType(accessType)
    {
    }
    
    void operator()(MethodInfoPtr method) const
    {
        auto m = std::make_shared<MethodInfo>(*method);
        if (m_accessType != reflection::AccessType::Undefined)
        {
            m->accessType = m_accessType;
        }
        
        m_target->methods.push_back(m);
    }
    
    template<typename U>
    void operator()(U) const
    {
    }
    
private:
    ClassInfoPtr m_target;
    reflection::AccessType m_accessType;
};

boost::apply_visitor(ObjectInjector(targetClass, ConvertVisibility(visibility)), obj.GetValue());

template<typename Visitor, typename V1>
static R apply(const Visitor& v, const V1& arg)
{
    switch( arg.index() )
    {
    {% for n in range(NumParams) -%}
    case {{n}}: return apply_visitor<{{n}}>(v, arg);
    {% endfor %}
    default: return R();
    }
}

constexpr void interface(meta::type target, const meta::type source) {   // 1
    compiler.require(source.variables().empty(), "interfaces may not contain data"); // 2
    
    for (auto f : source.functions())  {   // 3
        compiler.require(!f.is_copy() && !f.is_move(), "interfaces may not copy or move; consider a virtual clone() instead"); // 3.1
        
        if (!f.has_access()) // 3.2
            f.make_public();
        
        compiler.require(f.is_public(), "interface functions must be public"); // 3.3 
        
        f.make_pure_virtual();   // 3.4
        
        ->(target) f; // 3.5
    }
    ->(target) { virtual ~(source.name()$)() noexcept {} } // 4
}

interface Shape {
    int area() const;
    void scale_by(double factor);
};
или, альтернативный вариант:
class(interface) Shape {
    int area() const;
    void scale_by(double factor);
};
('interface' здесь - это название метакласса) внутри компилятора создаст декларацию:
class Shape {
public:
    virtual ~Shape() {}
    virtual int area() const = 0;
    virtual void scale_by(double factor) = 0;
};

template <typename T> std::string get_type_name() {
    namespace reflect = std::experimental::reflect;
    // Для шаблонного параметра reflexpr вернёт типа reflect::Alias с информацией об алиасе некоего типа:
    using T_t = reflexpr(T);
    // Теперь мы получаем информацию об оригинальном типе, с которым инстанцировали get_type_name:
    using aliased_T_t = reflect::get_aliased_t<T_t>;
    // Ну и получаем имя этого типа
    return reflect::get_name_v<aliased_T_t>;
}

template <typename T> std::string get_type_name() {
    auto T_t = $T;
    return T_t.name();
}

->(target) {virtual ~(source.name()$)() noexcept {} }

template<basic_enum E> // constrained to enum types
std::string to_string(E e) {
    switch (value) {
    constexpr {
        for (const auto o : $E.variables())
            if (!o.default_value.empty()) 
                -> { case o.default_value()$: return std::string(o.name()$); }
    }
    }
}