├── LICENSE
├── Makefile
├── README.md
├── reflection++
    ├── accessor.hpp
    ├── accessor_infer.hpp
    ├── holder.hpp
    ├── meta.hpp
    ├── static_str.hpp
    ├── traits.hpp
    ├── utility.hpp
    ├── visitor.hpp
    ├── visitor
    │   ├── basic.hpp
    │   ├── bson.hpp
    │   ├── bson_view.hpp
    │   ├── json.hpp
    │   ├── mysql.hpp
    │   └── strtree.hpp
    └── visitor_chain.hpp
└── tests
    ├── common.hpp
    ├── main.cpp
    ├── main_dup.cpp
    ├── meta.cpp
    ├── static_str.cpp
    ├── visitor_bson.cpp
    ├── visitor_chain.cpp
    ├── visitor_json.cpp
    └── visitor_strtree.cpp


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 hcz
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CC = clang++
 2 | 
 3 | FLAGS = -Wall -Wextra -pedantic -ferror-limit=1 -std=c++11 -O0 -g
 4 | 
 5 | CFLAGS = `pkg-config --cflags libbsoncxx`
 6 | LFLAGS = `pkg-config --libs libbsoncxx`
 7 | 
 8 | NM = nm
 9 | 
10 | NMFLAGS = -C -l -p -S
11 | 
12 | CAT = less
13 | 
14 | HPP_COMMON = $(wildcard reflection++/*.hpp)
15 | HPP_VISITOR = $(wildcard reflection++/visitor/*.hpp)
16 | HPP_TESTS = tests/common.hpp
17 | CPP_MAIN = tests/main.cpp
18 | CPP_TESTS = $(wildcard tests/*.cpp)
19 | 
20 | default:
21 | 	echo "make test\nmake pp\nmake nm\nmake clean"
22 | 
23 | tests.out: $(HPP_COMMON) $(HPP_VISITOR) $(HPP_TESTS) $(CPP_TESTS)
24 | 	$(CC) $(FLAGS) $(CFLAGS) $(LFLAGS) $(CPP_TESTS) -o $@
25 | 
26 | main.cpp.out: $(HPP_COMMON) $(HPP_VISITOR) $(HPP_TESTS) $(CPP_TESTS)
27 | 	$(CC) -E $(FLAGS) $(CFLAGS) $(CPP_MAIN) -o $@
28 | 
29 | names.nm.out: tests.out
30 | 	$(NM) $(NMFLAGS) $< > $@
31 | 
32 | test: tests.out
33 | 	./$<
34 | 
35 | pp: main.cpp.out
36 | 	$(CAT) $<
37 | 
38 | nm: names.nm.out
39 | 	$(CAT) $<
40 | 
41 | clean:
42 | 	touch rm_placeholder.out
43 | 	rm *.out
44 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Reflection++
 2 | ===
 3 | 
 4 | Yet another (?) header-only C++11 reflection library.
 5 | 
 6 | Usage
 7 | ---
 8 | 
 9 | Add meta information to an object:
10 | 
11 |     struct TestStruct {
12 |         int member1;
13 |         float member2;
14 |     };
15 |     RPP_TYPE_OBJECT(
16 |         __(member1)
17 |         __(member2),
18 |         TestStruct
19 |     )
20 | 
21 | Add meta information to an STL container:
22 | 
23 |     template <class T, class... Args>
24 |     RPP_TYPE_DYNAMIC_GENERIC(T, std::vector<T, Args...>)
25 | 
26 | Create a visitor:
27 | 
28 |     struct Visitor: public VisitorBase<> {
29 |         void visit(int &value) {
30 |             std::cerr << "int(" << value << ") ";
31 |         }
32 | 
33 |         void visit(float &value) {
34 |             std::cerr << "float(" << value << ") ";
35 |         }
36 | 
37 |         template <class... Args>
38 |         void operator()(AccessorSimple<Args...> &accessor) {
39 |             visit(accessor());
40 |         }
41 | 
42 |         template <class... Args>
43 |         void operator()(AccessorObject<Args...> &accessor) {
44 |             std::cerr << "object( ";
45 | 
46 |             for (rpp_size_t i = 0; i < accessor.size(); ++i) {
47 |                 accessor.doMemberVisit(*this, i);
48 |             }
49 | 
50 |             std::cerr << ") ";
51 |         }
52 |     };
53 | 
54 | Register the visitor and list all visitors:
55 | 
56 |     RPP_VISITOR_REG(Visitor)
57 |     RPP_VISITOR_COLLECT(VisitorAll)
58 | 
59 | Add meta information to a variable:
60 | 
61 |     TestStruct s{2, 3.5};
62 |     RPP_META_REF(s, VisitorAll) m;
63 | 
64 | Visit the variable:
65 | 
66 |     Visitor v;
67 |     m.doVisit(v);
68 | 
69 | Build
70 | ---
71 | 
72 | Compile it like this:
73 | 
74 |     clang++ -std=c++11 your_code.cpp
75 | 
76 | If you want to use the BSON visitor, [bson-cxx](https://github.com/mongodb/mongo-cxx-driver) is required.
77 | 


--------------------------------------------------------------------------------
/reflection++/accessor.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "holder.hpp"
  4 | 
  5 | namespace rpp {
  6 | 
  7 | // to construct accessors as a member of object
  8 | template <class T>
  9 | struct AccessorFactory {
 10 |     // static only
 11 |     AccessorFactory() = delete;
 12 | 
 13 |     template <class Object, class Accessor = T>
 14 |     static auto make(Object &) -> decltype(Accessor{}) {
 15 |         return Accessor{};
 16 |     }
 17 | 
 18 |     template <class Object, class Accessor = T>
 19 |     static auto make(Object &object) -> decltype(Accessor{object}) {
 20 |         return Accessor{object};
 21 |     }
 22 | };
 23 | 
 24 | // data accessors of simple data
 25 | template <class Value>
 26 | struct AccessorSimple: public Value {
 27 |     using Value::Value;
 28 | 
 29 |     using Type = AccessorSimple<
 30 |         HolderType<GetReturn<Value>>
 31 |     >;
 32 | };
 33 | 
 34 | // helper class of AccessObject
 35 | // add information of object members to an accessor
 36 | template <class Value, class Members>
 37 | struct AccessorObjectHelper;
 38 | 
 39 | template <class Value>
 40 | struct AccessorObjectHelper<
 41 |     Value, TypeList<>
 42 | >: public Value {
 43 |     using Value::Value;
 44 | 
 45 |     using MemberTypes = TypeList<>;
 46 | 
 47 |     rpp_size_t size() {
 48 |         return 0;
 49 |     }
 50 | 
 51 |     const char *getMemberName(rpp_size_t) {
 52 |         throw Exception{};
 53 |     }
 54 | 
 55 |     template <class Visitor>
 56 |     typename Visitor::ReturnType doMemberVisit(Visitor &, rpp_size_t) {
 57 |         throw Exception{};
 58 |     }
 59 | };
 60 | 
 61 | template <class Value, class Name, class Member, class... Args>
 62 | struct AccessorObjectHelper<
 63 |     Value, TypeList<Name, Member, Args...>
 64 | >: public AccessorObjectHelper<Value, TypeList<Args...>> {
 65 |     using AccessorObjectHelper<Value, TypeList<Args...>>::AccessorObjectHelper;
 66 | 
 67 |     using MemberTypes = typename AccessorObjectHelper<Value, TypeList<Args...>>
 68 |         ::MemberTypes
 69 |         ::template Push<typename Member::Type>
 70 |         ::template Push<Name>;
 71 | 
 72 |     rpp_size_t size() {
 73 |         return 1 + AccessorObjectHelper<Value, TypeList<Args...>>::size();
 74 |     }
 75 | 
 76 |     const char *getMemberName(rpp_size_t index) {
 77 |         if (index == 0) {
 78 |             // notice: Name is a holder object
 79 |             return AccessorFactory<Name>::make((*this)())();
 80 |         } else {
 81 |             return AccessorObjectHelper<Value, TypeList<Args...>>
 82 |                 ::getMemberName(index - 1);
 83 |         }
 84 |     }
 85 | 
 86 |     template <class Visitor>
 87 |     typename Visitor::ReturnType doMemberVisit(Visitor &visitor, rpp_size_t index) {
 88 |         if (index == 0) {
 89 |             // notice: can not use universal init here
 90 |             auto member = AccessorFactory<Member>::make((*this)());
 91 | 
 92 |             return visitor(member);
 93 |         } else {
 94 |             return AccessorObjectHelper<Value, TypeList<Args...>>
 95 |                 ::template doMemberVisit<Visitor>(visitor, index - 1);
 96 |         }
 97 |     }
 98 | };
 99 | 
100 | // data accessors associated with members
101 | template <class Value, class Members>
102 | struct AccessorObject: public AccessorObjectHelper<Value, Members> {
103 |     using AccessorObjectHelper<Value, Members>::AccessorObjectHelper;
104 | 
105 |     using Type = AccessorObject<
106 |         HolderType<GetReturn<Value>>,
107 |         typename AccessorObjectHelper<Value, Members>::MemberTypes
108 |     >;
109 | };
110 | 
111 | // data accessors associated with dynamic members
112 | template <class Value, class Member>
113 | struct AccessorDynamic: public Value {
114 |     using Value::Value;
115 | 
116 |     using Type = AccessorDynamic<
117 |         HolderType<GetReturn<Value>>,
118 |         typename Member::Type
119 |     >;
120 | 
121 |     template <class Visitor, class T>
122 |     typename Visitor::ReturnType doMemberVisit(Visitor &visitor, T &value) {
123 |         auto member = AccessorFactory<Member>::make(value);
124 | 
125 |         return visitor(member);
126 |     }
127 | };
128 | 
129 | }
130 | 


--------------------------------------------------------------------------------
/reflection++/accessor_infer.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "accessor.hpp"
  4 | 
  5 | namespace rpp {
  6 | 
  7 | // a compile-time wraper class of AccessorSimple
  8 | template <class Nothing = void>
  9 | struct AccessorSimpleWrap {
 10 |     template <class Value>
 11 |     using Accessor = AccessorSimple<Value>;
 12 | 
 13 |     // compile-time only
 14 |     AccessorSimpleWrap() = delete;
 15 | };
 16 | 
 17 | // a compile-time wraper class of AccessorObject
 18 | template <class Members>
 19 | struct AccessorObjectWrap {
 20 |     using List = Members;
 21 | 
 22 |     template <class Value>
 23 |     using Accessor = AccessorObject<Value, Members>;
 24 | 
 25 |     // compile-time only
 26 |     AccessorObjectWrap() = delete;
 27 | };
 28 | 
 29 | // a compile-time wraper class of AccessorDynamic
 30 | template <class Member>
 31 | struct AccessorDynamicWrap {
 32 |     template <class Value>
 33 |     using Accessor = AccessorDynamic<Value, Member>;
 34 | 
 35 |     // compile-time only
 36 |     AccessorDynamicWrap() = delete;
 37 | };
 38 | 
 39 | // get the default accessor
 40 | #define RPP_ACCESSOR(Value) \
 41 |     typename AccessorInfer< \
 42 |         rpp::GetReturn<Value> \
 43 |     >::template Accessor<Value>
 44 | 
 45 | // get the default accessor, bind the holder's type
 46 | #define RPP_ACCESSOR_AS(Mode, ...) \
 47 |     RPP_ACCESSOR(RPP_HOLDER_##Mode(__VA_ARGS__))
 48 | 
 49 | // enable AccessorInfer in the current namespace
 50 | #define RPP_ACCESSOR_INFER_INIT() \
 51 |     /* an abstract function to infer the default accessor of a type */ \
 52 |     template <class T> \
 53 |     struct AccessorInfer final: public rpp::AccessorSimpleWrap<> { \
 54 |         /* compile-time only */ \
 55 |         AccessorInfer() = delete; \
 56 |     };
 57 | 
 58 | RPP_ACCESSOR_INFER_INIT()
 59 | 
 60 | // helper macros begin
 61 | 
 62 |     // append an accessor to a TypeList
 63 |     #define RPP_ACCESSOR_APPEND_ACCESSOR(Object, Name, Accessor) \
 64 |         ::Append<Name>::Append<Accessor>
 65 |     // append an accessor to a TypeList (using default accessors)
 66 |     // wrappers of RPP_ACCESSOR_AS
 67 |     // notice: LOCAL or DYNAMIC as member means type casting
 68 |     #define RPP_ACCESSOR_APPEND_TYPE(Object, Type) \
 69 |         ::Append<RPP_HOLDER_STR(#Type)>::Append<RPP_ACCESSOR_AS(TYPE, Object::Type)>
 70 |     #define RPP_ACCESSOR_APPEND_CONST(Object, Value) \
 71 |         ::Append<RPP_HOLDER_STR(#Value)>::Append<RPP_ACCESSOR_AS(CONST, Object::Value)>
 72 |     #define RPP_ACCESSOR_APPEND_LOCAL(Object, Type) \
 73 |         ::Append<RPP_HOLDER_STR(#Type)>::Append<RPP_ACCESSOR_AS(LOCAL, Type)>
 74 |     #define RPP_ACCESSOR_APPEND_REF(Object, Value) \
 75 |         ::Append<RPP_HOLDER_STR(#Value)>::Append<RPP_ACCESSOR_AS(REF, Object::Value)>
 76 |     #define RPP_ACCESSOR_APPEND_DYNAMIC(Object, Type) \
 77 |         ::Append<RPP_HOLDER_STR(#Type)>::Append<RPP_ACCESSOR_AS(DYNAMIC, Type)>
 78 |     #define RPP_ACCESSOR_APPEND_MEMBER(Object, Value) \
 79 |         ::Append<RPP_HOLDER_STR(#Value)>::Append<RPP_ACCESSOR_AS(MEMBER, Object, Value)>
 80 |     // append an accessor wraps a base type to a TypeList
 81 |     #define RPP_ACCESSOR_APPEND_BASE(Derived, Base) \
 82 |         RPP_ACCESSOR_APPEND_DYNAMIC(Derived, Base)
 83 |     // append accessors of a base type (fetched from AccessorObjectWrap) to a TypeList
 84 |     #define RPP_ACCESSOR_APPEND_BASE_INLINE(Derived, Base) \
 85 |         ::AppendList<AccessorInfer<Base &>::List>
 86 | 
 87 |     // build a TypeList of accessors
 88 |     #define RPP_MEMBER_IMPL(Member, Mode, ...) \
 89 |         , RPP_MEMBER_LIST), RPP_ACCESSOR_APPEND_##Mode, Member
 90 |     #define RPP_MEMBER_LIST_BEGIN(Object, Next) \
 91 |         Next##_1(Object
 92 |     #define RPP_MEMBER_LIST_1(Object, Mode, Member, Next) \
 93 |         Mode(Object, Member) Next##_2(Object
 94 |     #define RPP_MEMBER_LIST_2(Object, Mode, Member, Next) \
 95 |         Mode(Object, Member) Next##_1(Object
 96 |     #define RPP_MEMBER_LIST_END_1(...) /* nothing */
 97 |     #define RPP_MEMBER_LIST_END_2(...) /* nothing */
 98 | 
 99 | // helper macros end
100 | 
101 | // define a member in RPP_TYPE_OBJECT
102 | #define RPP_MEMBER(...) \
103 |     RPP_MEMBER_IMPL(__VA_ARGS__, MEMBER, )
104 | #ifndef __
105 |     #define __ RPP_MEMBER
106 | #endif
107 | 
108 | // set the default accessor to AccessorObject and bind members
109 | #define RPP_TYPE_OBJECT(Members, Object) \
110 |     template <> \
111 |     struct AccessorInfer<Object &>: public rpp::AccessorObjectWrap< \
112 |         rpp::TypeList<> \
113 |         RPP_MEMBER_LIST_BEGIN( \
114 |             Object \
115 |             Members \
116 |             , RPP_MEMBER_LIST_END) \
117 |         ) \
118 |     > {};
119 | 
120 | // set the default accessor to AccessorDynamic and bind the (abstract) member
121 | #define RPP_TYPE_DYNAMIC(Member, Object) \
122 |     template <> \
123 |     struct AccessorInfer<Object &>: public rpp::AccessorDynamicWrap< \
124 |         RPP_ACCESSOR_AS(DYNAMIC, Member) \
125 |     > {};
126 | 
127 | // RPP_TYPE_OBJECT with template arguments
128 | // __VA_ARGS__ is the type of object
129 | #define RPP_TYPE_OBJECT_GENERIC(Members, ...) \
130 |     /* before the macro: template <???> */ \
131 |     struct AccessorInfer<rpp::GetRef<__VA_ARGS__>>: public rpp::AccessorObjectWrap< \
132 |         rpp::TypeList<> \
133 |         RPP_MEMBER_LIST_BEGIN( \
134 |             RPP_PASS(__VA_ARGS__) \
135 |             Members \
136 |             , RPP_MEMBER_LIST_END) \
137 |         ) \
138 |     > {};
139 | 
140 | // RPP_TYPE_DYNAMIC with template arguments
141 | // __VA_ARGS__ is the type of object
142 | #define RPP_TYPE_DYNAMIC_GENERIC(Member, ...) \
143 |     /* before the macro: template <???> */ \
144 |     struct AccessorInfer<rpp::GetRef<__VA_ARGS__>>: public rpp::AccessorDynamicWrap< \
145 |         RPP_ACCESSOR_AS(DYNAMIC, Member) \
146 |     > {};
147 | 
148 | }
149 | 


--------------------------------------------------------------------------------
/reflection++/holder.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "traits.hpp"
  4 | #include "static_str.hpp"
  5 | 
  6 | namespace rpp {
  7 | 
  8 | // data holders that hold types
  9 | template <class T>
 10 | struct HolderType {
 11 |     HolderType() {}
 12 | 
 13 |     const HolderType<T> &operator()() {
 14 |         return *this;
 15 |     }
 16 | };
 17 | 
 18 | // data holders that hold data as a static variable in a function
 19 | // allow constant only
 20 | template <class T, T _value>
 21 | struct HolderConst {
 22 |     HolderConst() {}
 23 | 
 24 |     const T &operator()() {
 25 |         static const T value{_value};
 26 | 
 27 |         return value;
 28 |     }
 29 | };
 30 | 
 31 | // data holders that hold data by themselves
 32 | template <class T>
 33 | struct HolderLocal {
 34 |     T value;
 35 | 
 36 |     HolderLocal(T &&_value): value(static_cast<T &&>(_value)) {}
 37 |     HolderLocal(const T &_value): value(_value) {}
 38 |     // HolderLocal(T &&_value): value{static_cast<T &&>(_value)} {}
 39 |     // HolderLocal(const T &_value): value{_value} {}
 40 | 
 41 |     T &operator()() {
 42 |         return value;
 43 |     }
 44 | };
 45 | 
 46 | // data holders point to a specified variable
 47 | template <class T, T &value>
 48 | struct HolderRef {
 49 |     HolderRef() {}
 50 | 
 51 |     T &operator()() {
 52 |         return value;
 53 |     }
 54 | };
 55 | 
 56 | // data holders point to a run-time variable
 57 | template <class T>
 58 | struct HolderDynamic {
 59 |     T &value;
 60 | 
 61 |     HolderDynamic(T &_value): value{_value} {}
 62 | 
 63 |     T &operator()() {
 64 |         return value;
 65 |     }
 66 | };
 67 | 
 68 | // data holders point to a specified member of a class
 69 | template <class Object, class T, T Object::*member>
 70 | struct HolderMember {
 71 |     Object &object;
 72 | 
 73 |     HolderMember(
 74 |         Object &_object
 75 |     ): object{_object} {}
 76 | 
 77 |     T &operator()() {
 78 |         return object.*member;
 79 |     }
 80 | };
 81 | 
 82 | // generate a holder type
 83 | #define RPP_HOLDER_TYPE(...) \
 84 |     rpp::HolderType<__VA_ARGS__>
 85 | #define RPP_HOLDER_CONST(...) \
 86 |     rpp::HolderConst<decltype(__VA_ARGS__), __VA_ARGS__>
 87 | #define RPP_HOLDER_STR(...) \
 88 |     rpp::HolderConst<const char (&)[], RPP_STATIC_STR(__VA_ARGS__)>
 89 | #define RPP_HOLDER_LOCAL(...) \
 90 |     rpp::HolderLocal<__VA_ARGS__>
 91 | #define RPP_HOLDER_REF(...) \
 92 |     rpp::HolderRef<decltype(__VA_ARGS__), __VA_ARGS__>
 93 | #define RPP_HOLDER_DYNAMIC(...) \
 94 |     rpp::HolderDynamic<__VA_ARGS__>
 95 | #define RPP_HOLDER_MEMBER(Object, ...) \
 96 |     rpp::HolderMember< \
 97 |         decltype(rpp::memberToObject(&Object::__VA_ARGS__)), \
 98 |         decltype(Object::__VA_ARGS__), \
 99 |         &Object::__VA_ARGS__ \
100 |     >
101 | 
102 | }
103 | 


--------------------------------------------------------------------------------
/reflection++/meta.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "accessor_infer.hpp"
 4 | 
 5 | namespace rpp {
 6 | 
 7 | // the base class of meta information containers
 8 | template <class Visitors>
 9 | struct MetaBase;
10 | 
11 | template <>
12 | struct MetaBase<
13 |     TypeList<>
14 | > {
15 |     virtual const char *getName() = 0;
16 | 
17 |     // see: using MetaBase<TypeList<Args...>>::doVisit
18 |     void doVisit() = delete;
19 | };
20 | 
21 | template <class Visitor, class... Args>
22 | struct MetaBase<
23 |     TypeList<Visitor, Args...>
24 | >: public MetaBase<TypeList<Args...>> {
25 |     using MetaBase<TypeList<Args...>>::doVisit;
26 | 
27 |     virtual typename Visitor::ReturnType doVisit(Visitor &visitor) = 0;
28 | };
29 | 
30 | // the implementation of MetaBase
31 | // implemented vitrual functions
32 | template <class Name, class Accessor, class Visitors, class Base = MetaBase<Visitors>>
33 | struct MetaImpl;
34 | 
35 | template <class Name, class Accessor, class Base>
36 | struct MetaImpl<
37 |     Name, Accessor, TypeList<>, Base
38 | >: public Base, protected Name, protected Accessor {
39 |     using Accessor::Accessor;
40 |     using Base::doVisit;
41 | 
42 |     virtual const char *getName() override {
43 |         return (*static_cast<Name *>(this))();
44 |     }
45 | };
46 | 
47 | template <class Name, class Accessor, class Visitor, class... Args, class Base>
48 | struct MetaImpl<
49 |     Name, Accessor, TypeList<Visitor, Args...>, Base
50 | >: public MetaImpl<Name, Accessor, TypeList<Args...>, Base> {
51 |     using MetaImpl<Name, Accessor, TypeList<Args...>, Base>::MetaImpl;
52 |     using MetaImpl<Name, Accessor, TypeList<Args...>, Base>::doVisit;
53 | 
54 |     virtual typename Visitor::ReturnType doVisit(Visitor &visitor) override {
55 |         return visitor(*static_cast<Accessor *>(this));
56 |     }
57 | };
58 | 
59 | // generate a meta info type
60 | // wrappers of RPP_ACCESSOR_AS
61 | #define RPP_META_TYPE(Type, ...) \
62 |     rpp::MetaImpl< \
63 |         RPP_HOLDER_STR(#Type), \
64 |         RPP_ACCESSOR_AS(TYPE, Type), \
65 |         __VA_ARGS__ \
66 |     >
67 | #define RPP_META_CONST(Value, ...) \
68 |     rpp::MetaImpl< \
69 |         RPP_HOLDER_STR(#Value), \
70 |         RPP_ACCESSOR_AS(CONST, Value), \
71 |         __VA_ARGS__ \
72 |     >
73 | #define RPP_META_LOCAL(Name, Type, ...) \
74 |     rpp::MetaImpl< \
75 |         RPP_HOLDER_STR(Name), \
76 |         RPP_ACCESSOR_AS(LOCAL, Type), \
77 |         __VA_ARGS__ \
78 |     >
79 | #define RPP_META_REF(Value, ...) \
80 |     rpp::MetaImpl< \
81 |         RPP_HOLDER_STR(#Value), \
82 |         RPP_ACCESSOR_AS(REF, Value), \
83 |         __VA_ARGS__ \
84 |     >
85 | #define RPP_META_DYNAMIC(Name, Type, ...) \
86 |     rpp::MetaImpl< \
87 |         RPP_HOLDER_STR(Name), \
88 |         RPP_ACCESSOR_AS(DYNAMIC, Type), \
89 |         __VA_ARGS__ \
90 |     >
91 | #define RPP_META_MEMBER(Object, Value, ...) \
92 |     rpp::MetaImpl< \
93 |         RPP_HOLDER_STR(#Value), \
94 |         RPP_ACCESSOR_AS(MEMBER, Object, Value), \
95 |         __VA_ARGS__ \
96 |     >
97 | 
98 | }
99 | 


--------------------------------------------------------------------------------
/reflection++/static_str.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "utility.hpp"
 4 | 
 5 | namespace rpp {
 6 | 
 7 | constexpr rpp_size_t strLen(const char *str, rpp_size_t index = 0) {
 8 |     return str[index] == 0 ? index : strLen(str, index + 1);
 9 | }
10 | 
11 | constexpr char strIndex(const char *str, rpp_size_t index) {
12 |     return index < strLen(str) ? str[index] : 0;
13 | }
14 | 
15 | // a compile-time string
16 | template <char tail, char... c>
17 | struct StaticStr final {
18 |     template <char next>
19 |     using Append = StaticStr<next, c..., tail>;
20 | 
21 |     // compile-time only
22 |     StaticStr() = delete;
23 | };
24 | 
25 | template <char... c>
26 | struct StaticStr<0, c...> final {
27 |     static const char str[];
28 | 
29 |     template <char next>
30 |     using Append = StaticStr<0, c...>;
31 | 
32 |     // compile-time only
33 |     StaticStr() = delete;
34 | };
35 | 
36 | template <char... c>
37 | const char StaticStr<0, c...>::str[]{c..., 0};
38 | 
39 | #define RPP_STATIC_STR(Str) \
40 |     ( \
41 |         rpp::StaticStr<rpp::strIndex((Str), 0)>::Append<rpp::strIndex((Str), 1)> \
42 |             ::Append<rpp::strIndex((Str), 2)>::Append<rpp::strIndex((Str), 3)> \
43 |             ::Append<rpp::strIndex((Str), 4)>::Append<rpp::strIndex((Str), 5)> \
44 |             ::Append<rpp::strIndex((Str), 6)>::Append<rpp::strIndex((Str), 7)> \
45 |             ::Append<rpp::strIndex((Str), 8)>::Append<rpp::strIndex((Str), 9)> \
46 |             ::Append<rpp::strIndex((Str), 10)>::Append<rpp::strIndex((Str), 11)> \
47 |             ::Append<rpp::strIndex((Str), 12)>::Append<rpp::strIndex((Str), 13)> \
48 |             ::Append<rpp::strIndex((Str), 14)>::Append<rpp::strIndex((Str), 15)> \
49 |             ::Append<rpp::strIndex((Str), 16)>::Append<rpp::strIndex((Str), 17)> \
50 |             ::Append<rpp::strIndex((Str), 18)>::Append<rpp::strIndex((Str), 19)> \
51 |             ::Append<rpp::strIndex((Str), 20)>::Append<rpp::strIndex((Str), 21)> \
52 |             ::Append<rpp::strIndex((Str), 22)>::Append<rpp::strIndex((Str), 23)> \
53 |             ::Append<rpp::strIndex((Str), 24)>::Append<rpp::strIndex((Str), 25)> \
54 |             ::Append<rpp::strIndex((Str), 26)>::Append<rpp::strIndex((Str), 27)> \
55 |             ::Append<rpp::strIndex((Str), 28)>::Append<rpp::strIndex((Str), 29)> \
56 |             ::Append<rpp::strIndex((Str), 30)>::Append<rpp::strIndex((Str), 31)> \
57 |             ::Append<rpp::strIndex((Str), 32)>::Append<rpp::strIndex((Str), 33)> \
58 |             ::Append<rpp::strIndex((Str), 34)>::Append<rpp::strIndex((Str), 35)> \
59 |             ::Append<rpp::strIndex((Str), 36)>::Append<rpp::strIndex((Str), 37)> \
60 |             ::Append<rpp::strIndex((Str), 38)>::Append<rpp::strIndex((Str), 39)> \
61 |             ::Append<rpp::strIndex((Str), 40)>::Append<rpp::strIndex((Str), 41)> \
62 |             ::Append<rpp::strIndex((Str), 42)>::Append<rpp::strIndex((Str), 43)> \
63 |             ::Append<rpp::strIndex((Str), 44)>::Append<rpp::strIndex((Str), 45)> \
64 |             ::Append<rpp::strIndex((Str), 46)>::Append<rpp::strIndex((Str), 47)> \
65 |             ::Append<rpp::strIndex((Str), 48)>::Append<rpp::strIndex((Str), 49)> \
66 |             ::Append<rpp::strIndex((Str), 50)>::Append<rpp::strIndex((Str), 51)> \
67 |             ::Append<rpp::strIndex((Str), 52)>::Append<rpp::strIndex((Str), 53)> \
68 |             ::Append<rpp::strIndex((Str), 54)>::Append<rpp::strIndex((Str), 55)> \
69 |             ::Append<rpp::strIndex((Str), 56)>::Append<rpp::strIndex((Str), 57)> \
70 |             ::Append<rpp::strIndex((Str), 58)>::Append<rpp::strIndex((Str), 59)> \
71 |             ::Append<rpp::strIndex((Str), 60)>::Append<rpp::strIndex((Str), 61)> \
72 |             ::Append<rpp::strIndex((Str), 62)>::Append<rpp::strIndex((Str), 63)> \
73 |             ::str \
74 |     )
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/reflection++/traits.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace rpp {
 4 | 
 5 | // get a reference to a type
 6 | template <class T>
 7 | using GetRef = T &;
 8 | 
 9 | // get the return type of a function
10 | template <class T>
11 | using GetReturn = decltype((*static_cast<T *>(nullptr))());
12 | 
13 | // generate an error if the value is not true
14 | template <bool value>
15 | using Ensure = decltype(static_cast<void>(sizeof(char [value ? 1 : -1])));
16 | 
17 | // get the actual object of a member pointer
18 | template <class Object, class T>
19 | Object memberToObject(T Object::*);
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/reflection++/utility.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // TODO: include?
 4 | #define RPP_EXCEPTION_PRINT
 5 | #ifdef RPP_EXCEPTION_PRINT
 6 |     #include <iostream>
 7 | #endif
 8 | 
 9 | namespace rpp {
10 | 
11 | // type of size
12 | using rpp_size_t = unsigned long;
13 | 
14 | // exception
15 | struct Exception {
16 |     // TODO
17 |     Exception() {
18 |         //
19 |     }
20 | 
21 |     Exception(const char *file, const rpp_size_t line, const char *func) {
22 |         #ifdef RPP_EXCEPTION_PRINT
23 |             std::cerr << "ERROR: " << file << ":" << line << " " << func << std::endl;
24 |         #endif
25 |     }
26 | };
27 | 
28 | // wrap a type (for macro arguments)
29 | #define RPP_PASS(...) \
30 |     decltype((static_cast<auto (*)() -> __VA_ARGS__>(nullptr))())
31 | 
32 | // a compile-time type list to contain classes
33 | template <class... Args>
34 | struct TypeList final {
35 |     template <class... Args2>
36 |     using Push = TypeList<Args2..., Args...>;
37 | 
38 |     template <class... Args2>
39 |     using Append = TypeList<Args..., Args2...>;
40 | 
41 |     template <template <class...> class Template>
42 |     using Head = Template<Args...>;
43 | 
44 |     template <class T>
45 |     using PushList = typename T::template Head<Push>;
46 | 
47 |     template <class T>
48 |     using AppendList = typename T::template Head<Append>;
49 | 
50 |     // compile-time only
51 |     TypeList() = delete;
52 | 
53 |     // for type inference
54 |     static TypeList<Args...> instance();
55 | };
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------
/reflection++/visitor.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "utility.hpp"
 4 | 
 5 | namespace rpp {
 6 | 
 7 | // the base class of meta information visitors
 8 | template <class Return = void>
 9 | struct VisitorBase {
10 |     using ReturnType = Return;
11 | };
12 | 
13 | // visitors that ignore unknown values
14 | template <class Return = void>
15 | struct VisitorIgnoreBase: public VisitorBase<Return> {
16 |     Return operator()(...) {
17 |         static const Return value{};
18 | 
19 |         return value;
20 |     }
21 | };
22 | 
23 | template <>
24 | struct VisitorIgnoreBase<void>: public VisitorBase<void> {
25 |     void operator()(...) {}
26 | };
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/reflection++/visitor/basic.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../visitor_chain.hpp"
 4 | #include "../accessor.hpp"
 5 | 
 6 | #include <typeinfo>
 7 | 
 8 | namespace rpp {
 9 | 
10 | // get type_info object of a type
11 | template <bool dynamic = true>
12 | struct VisitorType: public VisitorBase<const std::type_info &> {
13 |     template <class T>
14 |     ReturnType visit(T &value) {
15 |         if (dynamic) {
16 |             return typeid(value);
17 |         } else {
18 |             return typeid(T);
19 |         }
20 |     }
21 | 
22 |     template <class T>
23 |     ReturnType visit(const HolderType<T> &) {
24 |         return typeid(T);
25 |     }
26 | 
27 |     template <class Accessor>
28 |     ReturnType operator()(Accessor &accessor) {
29 |         return visit(accessor());
30 |     }
31 | };
32 | 
33 | RPP_VISITOR_REG(VisitorType<true>)
34 | RPP_VISITOR_REG(VisitorType<false>)
35 | 
36 | // get size of a type
37 | template <bool dynamic = true>
38 | struct VisitorSize: public VisitorBase<rpp_size_t> {
39 |     template <class T>
40 |     ReturnType visit(T &value) {
41 |         if (dynamic) {
42 |             return sizeof(value);
43 |         } else {
44 |             return sizeof(T);
45 |         }
46 |     }
47 | 
48 |     template <class T>
49 |     ReturnType visit(const HolderType<T> &) {
50 |         return sizeof(T);
51 |     }
52 | 
53 |     template <class Accessor>
54 |     ReturnType operator()(Accessor &accessor) {
55 |         return visit(accessor());
56 |     }
57 | };
58 | 
59 | RPP_VISITOR_REG(VisitorSize<true>)
60 | RPP_VISITOR_REG(VisitorSize<false>)
61 | 
62 | // get pointer of a value
63 | template <class Pointer>
64 | struct VisitorPointer: public VisitorBase<Pointer> {
65 |     Pointer visit(...) {
66 |         throw Exception{};
67 |     }
68 | 
69 |     template <class T>
70 |     auto visit(T &value) -> decltype(static_cast<Pointer>(&value)) {
71 |         return static_cast<Pointer>(&value);
72 |     }
73 | 
74 |     template <class Accessor>
75 |     Pointer operator()(Accessor &accessor) {
76 |         return visit(accessor());
77 |     }
78 | };
79 | 
80 | RPP_VISITOR_REG(VisitorPointer<void *>)
81 | RPP_VISITOR_REG(VisitorPointer<const void *>)
82 | 
83 | }
84 | 


--------------------------------------------------------------------------------
/reflection++/visitor/bson.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "../visitor.hpp"
  4 | #include "../accessor.hpp"
  5 | 
  6 | #include <bsoncxx/builder/basic/document.hpp>
  7 | #include <bsoncxx/builder/basic/array.hpp>
  8 | #include <bsoncxx/builder/basic/kvp.hpp>
  9 | 
 10 | #include <functional>
 11 | #include <string>
 12 | #include <memory>
 13 | #include <array>
 14 | #include <deque>
 15 | #include <forward_list>
 16 | #include <list>
 17 | #include <vector>
 18 | #include <map>
 19 | #include <unordered_map>
 20 | 
 21 | namespace rpp {
 22 | 
 23 | // forward declaration
 24 | template <class Doc>
 25 | struct VisitorBSONRootDocBase;
 26 | 
 27 | // render a BSON (MongoDB data) object
 28 | template <class Base = VisitorBSONRootDocBase<bsoncxx::builder::basic::document>>
 29 | struct VisitorBSON: public Base {
 30 | public:
 31 |     using Base::Base;
 32 | 
 33 |     // pointer
 34 | 
 35 |     template <class Accessor, class... Args>
 36 |     void into(Accessor &accessor, std::shared_ptr<Args...> &value) {
 37 |         this->visitPtr(this, accessor, value);
 38 |     }
 39 | 
 40 |     template <class Accessor, class... Args>
 41 |     void into(Accessor &accessor, std::weak_ptr<Args...> &value) {
 42 |         this->visitPtr(this, accessor, value);
 43 |     }
 44 | 
 45 |     template <class Accessor, class... Args>
 46 |     void into(Accessor &accessor, std::unique_ptr<Args...> &value) {
 47 |         this->visitPtr(this, accessor, value);
 48 |     }
 49 | 
 50 |     template <class Accessor, class T>
 51 |     void into(Accessor &accessor, T *&value) {
 52 |         this->visitPtr(this, accessor, value);
 53 |     }
 54 | 
 55 |     // array
 56 | 
 57 |     template <class Accessor, class T, rpp_size_t size>
 58 |     void into(Accessor &accessor, T (&value)[size]) {
 59 |         this->visitArr(accessor, value);
 60 |     }
 61 | 
 62 |     template <class Accessor, class T, rpp_size_t size>
 63 |     void into(Accessor &accessor, std::array<T, size> &value) {
 64 |         this->visitArr(accessor, value);
 65 |     }
 66 | 
 67 |     template <class Accessor, class... Args>
 68 |     void into(Accessor &accessor, std::deque<Args...> &value) {
 69 |         this->visitArr(accessor, value);
 70 |     }
 71 | 
 72 |     template <class Accessor, class... Args>
 73 |     void into(Accessor &accessor, std::forward_list<Args...> &value) {
 74 |         this->visitArr(accessor, value);
 75 |     }
 76 | 
 77 |     template <class Accessor, class... Args>
 78 |     void into(Accessor &accessor, std::list<Args...> &value) {
 79 |         this->visitArr(accessor, value);
 80 |     }
 81 | 
 82 |     template <class Accessor, class... Args>
 83 |     void into(Accessor &accessor, std::vector<Args...> &value) {
 84 |         this->visitArr(accessor, value);
 85 |     }
 86 | 
 87 |     // map
 88 | 
 89 |     template <class Accessor, class... Args>
 90 |     void into(Accessor &accessor, std::map<Args...> &value) {
 91 |         this->visitMap(accessor, value);
 92 |     }
 93 | 
 94 |     template <class Accessor, class... Args>
 95 |     void into(Accessor &accessor, std::unordered_map<Args...> &value) {
 96 |         this->visitMap(accessor, value);
 97 |     }
 98 | 
 99 |     // handle different types of accessors
100 | 
101 |     template <class... Args>
102 |     void operator()(AccessorSimple<Args...> &accessor) {
103 |         this->visitVal(accessor());
104 |     }
105 | 
106 |     template <class... Args>
107 |     void operator()(AccessorObject<Args...> &accessor) {
108 |         this->visitObj(accessor);
109 |     }
110 | 
111 |     template <class... Args>
112 |     void operator()(AccessorDynamic<Args...> &accessor) {
113 |         into(accessor, accessor());
114 |     }
115 | };
116 | 
117 | // hold a document entry
118 | template <class Doc>
119 | struct VisitorBSONAddDocBase: public VisitorBase<void> {
120 | private:
121 |     Doc &doc;
122 |     std::string name;
123 | 
124 | protected:
125 |     template <class Member>
126 |     void add(Member &&member) {
127 |         doc.append(
128 |             bsoncxx::builder::basic::kvp(
129 |                 name, static_cast<Member &&>(member)
130 |             )
131 |         );
132 |     }
133 | 
134 |     template <class Member>
135 |     void add(const Member &member) {
136 |         doc.append(
137 |             bsoncxx::builder::basic::kvp(
138 |                 name, member
139 |             )
140 |         );
141 |     }
142 | 
143 | public:
144 |     VisitorBSONAddDocBase(Doc &_doc, const std::string &_name):
145 |         doc{_doc}, name{_name} {}
146 | };
147 | 
148 | // hold an array
149 | template <class Arr>
150 | struct VisitorBSONAddArrBase: public VisitorBase<void> {
151 | private:
152 |     Arr &arr;
153 | 
154 | protected:
155 |     template <class Member>
156 |     void add(Member &&member) {
157 |         arr.append(
158 |             static_cast<Member &&>(member)
159 |         );
160 |     }
161 | 
162 |     template <class Member>
163 |     void add(const Member &member) {
164 |         arr.append(
165 |             member
166 |         );
167 |     }
168 | 
169 | public:
170 |     VisitorBSONAddArrBase(Arr &_arr):
171 |         arr{_arr} {}
172 | };
173 | 
174 | // build a BSON object as an item in a document or an array
175 | template <class Base>
176 | struct VisitorBSONItemBase: public Base {
177 | protected:
178 |     template <class T>
179 |     void visitVal(const T &value) {
180 |         this->add(value);
181 |     }
182 | 
183 |     void visitVal(const uint32_t &value) {
184 |         this->add(static_cast<int32_t>(value));
185 |     }
186 | 
187 |     void visitVal(const uint64_t &value) {
188 |         this->add(static_cast<int64_t>(value));
189 |     }
190 | 
191 |     void visitVal(const char &value) {
192 |         this->add(std::string{} + value);
193 |     }
194 | 
195 |     // void visitVal(const wchar_t &value) {
196 |     //     this->add(std::string{} + value);
197 |     // }
198 | 
199 |     template <class Self, class Accessor, class T>
200 |     void visitPtr(Self *self, Accessor &accessor, T &value) {
201 |         if (value) {
202 |             accessor.doMemberVisit(*self, *value);
203 |         } else {
204 |             // notice: b_null is discouraged
205 |             this->visitVal(bsoncxx::types::b_null{});
206 |         }
207 |     }
208 | 
209 |     template <class Accessor, class T>
210 |     void visitArr(Accessor &accessor, T &value) {
211 |         using bsoncxx::builder::basic::sub_array;
212 | 
213 |         this->add([&](sub_array arr) {
214 |             auto begin = std::begin(value);
215 |             auto end = std::end(value);
216 |             for (auto i = begin; i != end; ++i) {
217 |                 VisitorBSON<
218 |                     VisitorBSONItemBase<
219 |                         VisitorBSONAddArrBase<sub_array>
220 |                     >
221 |                 > child{arr};
222 | 
223 |                 accessor.doMemberVisit(child, *i);
224 |             }
225 |         });
226 |     }
227 | 
228 |     template <class Accessor, class T>
229 |     void visitMap(Accessor &accessor, T &value) {
230 |         using bsoncxx::builder::basic::sub_document;
231 | 
232 |         this->add([&](sub_document doc) {
233 |             auto begin = std::begin(value);
234 |             auto end = std::end(value);
235 |             for (auto i = begin; i != end; ++i) {
236 |                 VisitorBSON<
237 |                     VisitorBSONItemBase<
238 |                         VisitorBSONAddDocBase<sub_document>
239 |                     >
240 |                 > child{doc, i->first};
241 | 
242 |                 accessor.doMemberVisit(child, i->second);
243 |             }
244 |         });
245 |     }
246 | 
247 |     template <class... Args>
248 |     void visitObj(AccessorObject<Args...> &accessor) {
249 |         using bsoncxx::builder::basic::sub_document;
250 | 
251 |         this->add([&](sub_document doc) {
252 |             for (rpp_size_t i = 0; i < accessor.size(); ++i) {
253 |                 VisitorBSON<
254 |                     VisitorBSONItemBase<
255 |                         VisitorBSONAddDocBase<sub_document>
256 |                     >
257 |                 > child{doc, accessor.getMemberName(i)};
258 | 
259 |                 accessor.doMemberVisit(child, i);
260 |             }
261 |         });
262 |     }
263 | 
264 | public:
265 |     using Base::Base;
266 | };
267 | 
268 | // build a BSON object as a root (type: document)
269 | template <class Doc = bsoncxx::builder::basic::document>
270 | struct VisitorBSONRootDocBase: public VisitorBase<void>, public Doc {
271 | protected:
272 |     template <class T>
273 |     void visitVal(const T &value) = delete;
274 | 
275 |     template <class Self, class Accessor, class T>
276 |     void visitPtr(Self *self, Accessor &accessor, T &value) = delete;
277 | 
278 |     template <class Accessor, class T>
279 |     void visitArr(Accessor &accessor, T &value) = delete;
280 | 
281 |     template <class Accessor, class T>
282 |     void visitMap(Accessor &accessor, T &value) {
283 |         auto begin = std::begin(value);
284 |         auto end = std::end(value);
285 |         for (auto i = begin; i != end; ++i) {
286 |             VisitorBSON<
287 |                 VisitorBSONItemBase<
288 |                     VisitorBSONAddDocBase<Doc>
289 |                 >
290 |             > child{*this, i->first};
291 | 
292 |             accessor.doMemberVisit(child, i->second);
293 |         }
294 |     }
295 | 
296 |     template <class... Args>
297 |     void visitObj(AccessorObject<Args...> &accessor) {
298 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
299 |             VisitorBSON<
300 |                 VisitorBSONItemBase<
301 |                     VisitorBSONAddDocBase<Doc>
302 |                 >
303 |             > child{*this, accessor.getMemberName(i)};
304 | 
305 |             accessor.doMemberVisit(child, i);
306 |         }
307 |     }
308 | };
309 | 
310 | // build a BSON object as root (type: array)
311 | template <class Arr = bsoncxx::builder::basic::array>
312 | struct VisitorBSONRootArrBase: public VisitorBase<void>, public Arr {
313 | protected:
314 |     template <class T>
315 |     void visitVal(const T &value) = delete;
316 | 
317 |     template <class Self, class Accessor, class T>
318 |     void visitPtr(Self *self, Accessor &accessor, T &value) = delete;
319 | 
320 |     template <class Accessor, class T>
321 |     void visitArr(Accessor &accessor, T &value) {
322 |         auto begin = std::begin(value);
323 |         auto end = std::end(value);
324 |         for (auto i = begin; i != end; ++i) {
325 |             VisitorBSON<
326 |                 VisitorBSONItemBase<
327 |                     VisitorBSONAddArrBase<Arr>
328 |                 >
329 |             > child{*this};
330 | 
331 |             accessor.doMemberVisit(child, *i);
332 |         }
333 |     }
334 | 
335 |     template <class Accessor, class T>
336 |     void visitMap(Accessor &accessor, T &value) = delete;
337 | 
338 |     template <class... Args>
339 |     void visitObj(AccessorObject<Args...> &accessor) = delete;
340 | };
341 | 
342 | }
343 | 


--------------------------------------------------------------------------------
/reflection++/visitor/bson_view.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "../visitor.hpp"
  4 | #include "../accessor.hpp"
  5 | 
  6 | #include <bsoncxx/types/value.hpp>
  7 | #include <bsoncxx/types.hpp>
  8 | 
  9 | #include <functional>
 10 | #include <string>
 11 | #include <memory>
 12 | #include <array>
 13 | #include <deque>
 14 | #include <forward_list>
 15 | #include <list>
 16 | #include <vector>
 17 | #include <map>
 18 | #include <unordered_map>
 19 | 
 20 | namespace rpp {
 21 | 
 22 | // forward declaration
 23 | template <class Element>
 24 | struct VisitorBSONViewItemBase;
 25 | 
 26 | // read data from a BSON (MongoDB data) view
 27 | template <class Base = VisitorBSONViewItemBase<bsoncxx::types::value>>
 28 | struct VisitorBSONView: public Base {
 29 | public:
 30 |     using Base::Base;
 31 | 
 32 |     // pointer
 33 | 
 34 |     template <class Accessor, class... Args>
 35 |     void into(Accessor &accessor, std::shared_ptr<Args...> &value) {
 36 |         this->visitPtr(this, accessor, value);
 37 |     }
 38 | 
 39 |     template <class Accessor, class... Args>
 40 |     void into(Accessor &accessor, std::weak_ptr<Args...> &value) {
 41 |         this->visitPtr(this, accessor, value);
 42 |     }
 43 | 
 44 |     template <class Accessor, class... Args>
 45 |     void into(Accessor &accessor, std::unique_ptr<Args...> &value) {
 46 |         this->visitPtr(this, accessor, value);
 47 |     }
 48 | 
 49 |     template <class Accessor, class T>
 50 |     void into(Accessor &accessor, T *&value) {
 51 |         this->visitPtr(this, accessor, value);
 52 |     }
 53 | 
 54 |     // array
 55 | 
 56 |     template <class Accessor, class T, rpp_size_t size>
 57 |     void into(Accessor &accessor, T (&value)[size]) {
 58 |         this->visitArr(accessor, value);
 59 |     }
 60 | 
 61 |     template <class Accessor, class T, rpp_size_t size>
 62 |     void into(Accessor &accessor, std::array<T, size> &value) {
 63 |         this->visitArr(accessor, value);
 64 |     }
 65 | 
 66 |     template <class Accessor, class... Args>
 67 |     void into(Accessor &accessor, std::deque<Args...> &value) {
 68 |         this->visitDynArr(accessor, value);
 69 |     }
 70 | 
 71 |     template <class Accessor, class... Args>
 72 |     void into(Accessor &accessor, std::forward_list<Args...> &value) {
 73 |         this->visitDynArr(accessor, value);
 74 |     }
 75 | 
 76 |     template <class Accessor, class... Args>
 77 |     void into(Accessor &accessor, std::list<Args...> &value) {
 78 |         this->visitDynArr(accessor, value);
 79 |     }
 80 | 
 81 |     template <class Accessor, class... Args>
 82 |     void into(Accessor &accessor, std::vector<Args...> &value) {
 83 |         this->visitDynArr(accessor, value);
 84 |     }
 85 | 
 86 |     // map
 87 | 
 88 |     template <class Accessor, class... Args>
 89 |     void into(Accessor &accessor, std::map<Args...> &value) {
 90 |         this->visitDynMap(accessor, value);
 91 |     }
 92 | 
 93 |     template <class Accessor, class... Args>
 94 |     void into(Accessor &accessor, std::unordered_map<Args...> &value) {
 95 |         this->visitDynMap(accessor, value);
 96 |     }
 97 | 
 98 |     // handle different types of accessors
 99 | 
100 |     template <class... Args>
101 |     void operator()(AccessorSimple<Args...> &accessor) {
102 |         this->visitVal(accessor());
103 |     }
104 | 
105 |     template <class... Args>
106 |     void operator()(AccessorObject<Args...> &accessor) {
107 |         this->visitObj(accessor);
108 |     }
109 | 
110 |     template <class... Args>
111 |     void operator()(AccessorDynamic<Args...> &accessor) {
112 |         into(accessor, accessor());
113 |     }
114 | };
115 | 
116 | // read data from an element in a BSON object
117 | template <class Element>
118 | struct VisitorBSONViewItemBase: public VisitorBase<void>, private Element {
119 | private:
120 |     template <class To>
121 |     void castAssign(To &, ...) {
122 |         throw Exception{};
123 |     }
124 | 
125 |     template <class To, class From>
126 |     auto castAssign(To &to, From *from) -> decltype(
127 |         static_cast<void>(to = *from)
128 |     ) {
129 |         to = *from;
130 |     }
131 | 
132 |     // bsoncxx::stdx::string_view
133 |     template <class To, class From>
134 |     auto castAssign(To &to, From *from) -> decltype(
135 |         static_cast<void>(to = from->value.to_string())
136 |     ) {
137 |         to = from->value.to_string();
138 |     }
139 | 
140 | protected:
141 |     template <class T>
142 |     void visitVal(T &value) {
143 |         switch (this->type()) {
144 |             case bsoncxx::type::k_double:
145 |                 {
146 |                     auto from = this->get_double();
147 |                     castAssign(value, &from);
148 |                 }
149 |                 break;
150 |             case bsoncxx::type::k_utf8:
151 |                 {
152 |                     auto from = this->get_utf8();
153 |                     castAssign(value, &from);
154 |                 }
155 |                 break;
156 |             case bsoncxx::type::k_document:
157 |                 {
158 |                     auto from = this->get_document();
159 |                     castAssign(value, &from);
160 |                 }
161 |                 break;
162 |             case bsoncxx::type::k_array:
163 |                 {
164 |                     auto from = this->get_array();
165 |                     castAssign(value, &from);
166 |                 }
167 |                 break;
168 |             case bsoncxx::type::k_binary:
169 |                 {
170 |                     auto from = this->get_binary();
171 |                     castAssign(value, &from);
172 |                 }
173 |                 break;
174 |             // case bsoncxx::type::k_undefined:
175 |             //     {
176 |             //         auto from = this->get_undefined();
177 |             //         castAssign(value, &from);
178 |             //     }
179 |             //     break;
180 |             case bsoncxx::type::k_oid:
181 |                 {
182 |                     auto from = this->get_oid();
183 |                     castAssign(value, &from);
184 |                 }
185 |                 break;
186 |             case bsoncxx::type::k_bool:
187 |                 {
188 |                     auto from = this->get_bool();
189 |                     castAssign(value, &from);
190 |                 }
191 |                 break;
192 |             case bsoncxx::type::k_date:
193 |                 {
194 |                     auto from = this->get_date();
195 |                     castAssign(value, &from);
196 |                 }
197 |                 break;
198 |             case bsoncxx::type::k_null:
199 |                 // notice: b_null is discouraged
200 |                 {
201 |                     auto from = this->get_null();
202 |                     castAssign(value, &from);
203 |                 }
204 |                 break;
205 |             // case bsoncxx::type::k_regex:
206 |             //     {
207 |             //         auto from = this->get_regex();
208 |             //         castAssign(value, &from);
209 |             //     }
210 |             //     break;
211 |             // case bsoncxx::type::k_dbpointer:
212 |             //     {
213 |             //         auto from = this->get_dbpointer();
214 |             //         castAssign(value, &from);
215 |             //     }
216 |             //     break;
217 |             // case bsoncxx::type::k_code:
218 |             //     {
219 |             //         auto from = this->get_code();
220 |             //         castAssign(value, &from);
221 |             //     }
222 |             //     break;
223 |             // case bsoncxx::type::k_symbol:
224 |             //     {
225 |             //         auto from = this->get_symbol();
226 |             //         castAssign(value, &from);
227 |             //     }
228 |             //     break;
229 |             // case bsoncxx::type::k_codewscope:
230 |             //     {
231 |             //         auto from = this->get_codewscope();
232 |             //         castAssign(value, &from);
233 |             //     }
234 |             //     break;
235 |             case bsoncxx::type::k_int32:
236 |                 {
237 |                     auto from = this->get_int32();
238 |                     castAssign(value, &from);
239 |                 }
240 |                 break;
241 |             // case bsoncxx::type::k_timestamp:
242 |             //     {
243 |             //         auto from = this->get_timestamp();
244 |             //         castAssign(value, &from);
245 |             //     }
246 |             //     break;
247 |             case bsoncxx::type::k_int64:
248 |                 {
249 |                     auto from = this->get_int64();
250 |                     castAssign(value, &from);
251 |                 }
252 |                 break;
253 |             // case bsoncxx::type::k_maxkey:
254 |             //     {
255 |             //         auto from = this->get_maxkey();
256 |             //         castAssign(value, &from);
257 |             //     }
258 |             //     break;
259 |             // case bsoncxx::type::k_minkey:
260 |             //     {
261 |             //         auto from = this->get_minkey();
262 |             //         castAssign(value, &from);
263 |             //     }
264 |             //     break;
265 |             default:
266 |                 throw Exception{};
267 |                 break;
268 |         }
269 |     }
270 | 
271 |     void visitVal(char &value) {
272 |         std::string str;
273 | 
274 |         visitVal(str);
275 |         value = str[0];
276 |     }
277 | 
278 |     // void visitVal(wchar_t &value) {
279 |     //     std::wstring str;
280 | 
281 |     //     visitVal(str);
282 |     //     value = str[0];
283 |     // }
284 | 
285 |     template <class Self, class Accessor, class T>
286 |     void visitPtr(Self *self, Accessor &accessor, T &value) {
287 |         // TODO
288 |         if (this->type() == bsoncxx::type::k_null) {
289 |             // leak?
290 |             value = nullptr;
291 |         } else {
292 |             if (!value) {
293 |                 value = T{
294 |                     new typename std::pointer_traits<T>::element_type{}
295 |                 };
296 |             }
297 |             accessor.doMemberVisit(*self, *value);
298 |         }
299 |     }
300 | 
301 |     template <class Accessor, class T>
302 |     void visitArr(Accessor &accessor, T &value) {
303 |         if (this->type() != bsoncxx::type::k_array) {
304 |             throw Exception{};
305 |         }
306 | 
307 |         auto arr = this->get_array();
308 |         rpp_size_t index = 0;
309 | 
310 |         auto begin = std::begin(value);
311 |         auto end = std::end(value);
312 |         for (auto i = begin; i != end; ++i, ++index) {
313 |             auto child_element = arr.value[index];
314 | 
315 |             VisitorBSONView<
316 |                 VisitorBSONViewItemBase<
317 |                     bsoncxx::array::element
318 |                 >
319 |             > child{
320 |                 child_element.raw,
321 |                 child_element.length,
322 |                 child_element.offset
323 |             };
324 | 
325 |             accessor.doMemberVisit(child, *i);
326 |         }
327 |     }
328 | 
329 |     template <class Accessor, class T>
330 |     void visitDynArr(Accessor &accessor, T &value) {
331 |         if (this->type() != bsoncxx::type::k_array) {
332 |             throw Exception{};
333 |         }
334 | 
335 |         value.clear();
336 | 
337 |         auto arr = this->get_array();
338 | 
339 |         auto begin = std::begin(arr.value);
340 |         auto end = std::end(arr.value);
341 |         for (auto i = begin; i != end; ++i) {
342 |             VisitorBSONView<
343 |                 VisitorBSONViewItemBase<
344 |                     bsoncxx::array::element
345 |                 >
346 |             > child{
347 |                 i->raw,
348 |                 i->length,
349 |                 i->offset
350 |             };
351 | 
352 |             value.push_back({});
353 |             accessor.doMemberVisit(child, value.back());
354 |         }
355 |     }
356 | 
357 |     template <class Accessor, class T>
358 |     void visitMap(Accessor &accessor, T &value) {
359 |         if (this->type() != bsoncxx::type::k_document) {
360 |             throw Exception{};
361 |         }
362 | 
363 |         auto doc = this->get_document();
364 | 
365 |         auto begin = std::begin(value);
366 |         auto end = std::end(value);
367 |         for (auto i = begin; i != end; ++i) {
368 |             auto child_element = doc.value[
369 |                 bsoncxx::stdx::string_view{i->first}
370 |             ];
371 | 
372 |             VisitorBSONView<
373 |                 VisitorBSONViewItemBase<
374 |                     bsoncxx::document::element
375 |                 >
376 |             > child{
377 |                 child_element.raw,
378 |                 child_element.length,
379 |                 child_element.offset
380 |             };
381 | 
382 |             accessor.doMemberVisit(child, i->second);
383 |         }
384 |     }
385 | 
386 |     template <class Accessor, class T>
387 |     void visitDynMap(Accessor &accessor, T &value) {
388 |         if (this->type() != bsoncxx::type::k_document) {
389 |             throw Exception{};
390 |         }
391 | 
392 |         value.clear();
393 | 
394 |         auto doc = this->get_document();
395 | 
396 |         auto begin = std::begin(doc.value);
397 |         auto end = std::end(doc.value);
398 |         for (auto i = begin; i != end; ++i) {
399 |             // TODO: unknown bug
400 |             //       sometimes infinite loop (known: when doc is empty)
401 |             try {
402 |                 VisitorBSONView<
403 |                     VisitorBSONViewItemBase<
404 |                         bsoncxx::document::element
405 |                     >
406 |                 > child{
407 |                     i->raw,
408 |                     i->length,
409 |                     i->offset
410 |                 };
411 | 
412 |                 accessor.doMemberVisit(child, value[i->key().to_string()]);
413 |             } catch (...) {
414 |                 break;
415 |             }
416 |         }
417 |     }
418 | 
419 |     template <class... Args>
420 |     void visitObj(AccessorObject<Args...> &accessor) {
421 |         if (this->type() != bsoncxx::type::k_document) {
422 |             throw Exception{};
423 |         }
424 | 
425 |         auto doc = this->get_document();
426 | 
427 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
428 |             auto child_element = doc.value[
429 |                 bsoncxx::stdx::string_view{accessor.getMemberName(i)}
430 |             ];
431 | 
432 |             VisitorBSONView<
433 |                 VisitorBSONViewItemBase<
434 |                     bsoncxx::document::element
435 |                 >
436 |             > child{
437 |                 child_element.raw,
438 |                 child_element.length,
439 |                 child_element.offset
440 |             };
441 | 
442 |             accessor.doMemberVisit(child, i);
443 |         }
444 |     }
445 | 
446 | public:
447 |     using Element::Element;
448 | };
449 | 
450 | }
451 | 


--------------------------------------------------------------------------------
/reflection++/visitor/json.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "../visitor.hpp"
  4 | #include "../accessor.hpp"
  5 | 
  6 | #include <ostream>
  7 | #include <string>
  8 | #include <memory>
  9 | #include <array>
 10 | #include <deque>
 11 | #include <forward_list>
 12 | #include <list>
 13 | #include <vector>
 14 | #include <map>
 15 | #include <unordered_map>
 16 | 
 17 | namespace rpp {
 18 | 
 19 | // render a JSON string and write it into a stream
 20 | template <class Out = std::ostream>
 21 | struct VisitorJSON: public VisitorBase<void> {
 22 | private:
 23 |     Out &out;
 24 |     rpp_size_t indent;
 25 | 
 26 |     void writeIndent() {
 27 |         out << '\n';
 28 |         for (rpp_size_t i = 0; i < indent; ++i) {
 29 |             out << "    ";
 30 |         }
 31 |     }
 32 | 
 33 |     template <class T>
 34 |     void writeChar(T value) {
 35 |         switch (value) {
 36 |             case '"':
 37 |                 out << "\\\"";
 38 |                 break;
 39 |             case '\\':
 40 |                 out << "\\\\";
 41 |                 break;
 42 |             case '/':
 43 |                 out << "\\/";
 44 |                 break;
 45 |             case '\b':
 46 |                 out << "\\b";
 47 |                 break;
 48 |             case '\f':
 49 |                 out << "\\f";
 50 |                 break;
 51 |             case '\n':
 52 |                 out << "\\n";
 53 |                 break;
 54 |             case '\r':
 55 |                 out << "\\r";
 56 |                 break;
 57 |             case '\t':
 58 |                 out << "\\t";
 59 |                 break;
 60 |             default:
 61 |                 if (value >= 0 && value < 0x1f) {
 62 |                     out << "\\u00"
 63 |                         << ("01"[value >> 4])
 64 |                         << ("0123456789ABCDEF"[value & 0xf]);
 65 |                 } else {
 66 |                     out << value;
 67 |                 }
 68 |                 break;
 69 |         }
 70 |     }
 71 | 
 72 |     void visitStr(const char *value) {
 73 |         out << '"';
 74 | 
 75 |         for (; *value; ++value) {
 76 |             writeChar(*value);
 77 |         }
 78 | 
 79 |         out << '"';
 80 |     }
 81 | 
 82 |     void visitStr(const wchar_t *value) {
 83 |         out << '"';
 84 | 
 85 |         for (; *value; ++value) {
 86 |             writeChar(*value);
 87 |         }
 88 | 
 89 |         out << '"';
 90 |     }
 91 | 
 92 |     template <class... Args>
 93 |     void visitStr(const std::basic_string<Args...> &value) {
 94 |         out << '"';
 95 | 
 96 |         auto begin = std::begin(value);
 97 |         auto end = std::end(value);
 98 |         for (auto i = begin; i != end; ++i) {
 99 |             writeChar(*i);
100 |         }
101 | 
102 |         out << '"';
103 |     }
104 | 
105 |     template <class Accessor, class T>
106 |     void visitPtr(Accessor &accessor, T &value) {
107 |         if (value) {
108 |             accessor.doMemberVisit(*this, *value);
109 |         } else {
110 |             out << "null";
111 |         }
112 |     }
113 | 
114 |     template <class Accessor, class T>
115 |     void visitArr(Accessor &accessor, T &value) {
116 |         out << '[';
117 | 
118 |         auto begin = std::begin(value);
119 |         auto end = std::end(value);
120 |         for (auto i = begin; i != end; ++i) {
121 |             if (i != begin) {
122 |                 out << ", ";
123 |             }
124 |             accessor.doMemberVisit(*this, *i);
125 |         }
126 | 
127 |         out << ']';
128 |     }
129 | 
130 |     template <class Accessor, class T>
131 |     void visitMap(Accessor &accessor, T &value) {
132 |         out << '{';
133 |         ++indent;
134 | 
135 |         auto begin = std::begin(value);
136 |         auto end = std::end(value);
137 |         for (auto i = begin; i != end; ++i) {
138 |             if (i != begin) {
139 |                 out << ',';
140 |             }
141 |             writeIndent();
142 | 
143 |             visitStr(i->first);
144 |             out << ": ";
145 |             accessor.doMemberVisit(*this, i->second);
146 |         }
147 | 
148 |         --indent;
149 |         writeIndent();
150 |         out << '}';
151 |     }
152 | 
153 | public:
154 |     VisitorJSON(Out &_out, rpp_size_t _indent = 0):
155 |         out{_out}, indent{_indent} {}
156 | 
157 |     template <class T>
158 |     auto visit(const T value) -> Ensure<
159 |         static_cast<int>(static_cast<T>(2)) == 1
160 |     > {
161 |         out << (value ? "true" : "false");
162 |     }
163 | 
164 |     template <class T>
165 |     auto visit(const T value) -> Ensure<
166 |         static_cast<int>(static_cast<T>(2)) == 2
167 |     > {
168 |         out << std::to_string(value);
169 |     }
170 | 
171 |     // string
172 | 
173 |     void visit(const char &value) {
174 |         out << '"';
175 |         writeChar(value);
176 |         out << '"';
177 |     }
178 | 
179 |     void visit(const wchar_t &value) {
180 |         out << '"';
181 |         writeChar(value);
182 |         out << '"';
183 |     }
184 | 
185 |     void visit(const char *value) {
186 |         visitStr(value);
187 |     }
188 | 
189 |     void visit(const wchar_t *value) {
190 |         visitStr(value);
191 |     }
192 | 
193 |     template <class... Args>
194 |     void visit(const std::basic_string<Args...> &value) {
195 |         visitStr(value);
196 |     }
197 | 
198 |     // pointer
199 | 
200 |     template <class Accessor, class... Args>
201 |     void into(Accessor &accessor, std::shared_ptr<Args...> &value) {
202 |         visitPtr(accessor, value);
203 |     }
204 | 
205 |     template <class Accessor, class... Args>
206 |     void into(Accessor &accessor, std::weak_ptr<Args...> &value) {
207 |         visitPtr(accessor, value);
208 |     }
209 | 
210 |     template <class Accessor, class... Args>
211 |     void into(Accessor &accessor, std::unique_ptr<Args...> &value) {
212 |         visitPtr(accessor, value);
213 |     }
214 | 
215 |     template <class Accessor, class T>
216 |     void into(Accessor &accessor, T *&value) {
217 |         visitPtr(accessor, value);
218 |     }
219 | 
220 |     // array
221 | 
222 |     template <class Accessor, class T, rpp_size_t size>
223 |     void into(Accessor &accessor, T (&value)[size]) {
224 |         visitArr(accessor, value);
225 |     }
226 | 
227 |     template <class Accessor, class T, rpp_size_t size>
228 |     void into(Accessor &accessor, std::array<T, size> &value) {
229 |         visitArr(accessor, value);
230 |     }
231 | 
232 |     template <class Accessor, class... Args>
233 |     void into(Accessor &accessor, std::deque<Args...> &value) {
234 |         visitArr(accessor, value);
235 |     }
236 | 
237 |     template <class Accessor, class... Args>
238 |     void into(Accessor &accessor, std::forward_list<Args...> &value) {
239 |         visitArr(accessor, value);
240 |     }
241 | 
242 |     template <class Accessor, class... Args>
243 |     void into(Accessor &accessor, std::list<Args...> &value) {
244 |         visitArr(accessor, value);
245 |     }
246 | 
247 |     template <class Accessor, class... Args>
248 |     void into(Accessor &accessor, std::vector<Args...> &value) {
249 |         visitArr(accessor, value);
250 |     }
251 | 
252 |     // map
253 | 
254 |     template <class Accessor, class... Args>
255 |     void into(Accessor &accessor, std::map<Args...> &value) {
256 |         visitMap(accessor, value);
257 |     }
258 | 
259 |     template <class Accessor, class... Args>
260 |     void into(Accessor &accessor, std::unordered_map<Args...> &value) {
261 |         visitMap(accessor, value);
262 |     }
263 | 
264 |     // handle different types of accessors
265 | 
266 |     template <class... Args>
267 |     void operator()(AccessorSimple<Args...> &accessor) {
268 |         visit(accessor());
269 |     }
270 | 
271 |     template <class... Args>
272 |     void operator()(AccessorObject<Args...> &accessor) {
273 |         out << '{';
274 |         ++indent;
275 | 
276 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
277 |             if (i != 0) {
278 |                 out << ',';
279 |             }
280 |             writeIndent();
281 | 
282 |             visitStr(accessor.getMemberName(i));
283 |             out << ": ";
284 |             accessor.doMemberVisit(*this, i);
285 |         }
286 | 
287 |         --indent;
288 |         writeIndent();
289 |         out << '}';
290 |     }
291 | 
292 |     template <class... Args>
293 |     void operator()(AccessorDynamic<Args...> &accessor) {
294 |         into(accessor, accessor());
295 |     }
296 | };
297 | 
298 | }
299 | 


--------------------------------------------------------------------------------
/reflection++/visitor/mysql.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../visitor.hpp"
 4 | #include "../accessor.hpp"
 5 | 
 6 | #include <ostream>
 7 | #include <string>
 8 | 
 9 | namespace rpp {
10 | 
11 | // render a MySQL script and write it into a stream
12 | template <class Out = std::ostream>
13 | struct VisitorMySQLBase: public VisitorBase<void> {
14 | protected:
15 |     Out &out;
16 | 
17 |     void charEscape(char value) {
18 |         switch (value) {
19 |             case 0:
20 |                 out << "\\0";
21 |                 break;
22 |             case '\'':
23 |                 out << "\\'";
24 |                 break;
25 |             case '"':
26 |                 out << "\\\"";
27 |                 break;
28 |             case '`':
29 |                 out << "\\`";
30 |                 break;
31 |             case '\b':
32 |                 out << "\\b";
33 |                 break;
34 |             case '\n':
35 |                 out << "\\n";
36 |                 break;
37 |             case '\r':
38 |                 out << "\\r";
39 |                 break;
40 |             case '\t':
41 |                 out << "\\t";
42 |                 break;
43 |             case 26:
44 |                 out << "\\Z";
45 |                 break;
46 |             case '\\':
47 |                 out << "\\\\";
48 |                 break;
49 |             case '%':
50 |                 out << "\\%";
51 |                 break;
52 |             case '_':
53 |                 out << "\\_";
54 |                 break;
55 |             default:
56 |                 out << value;
57 |                 break;
58 |         }
59 |     }
60 | 
61 |     void stringEscape(std::string &value) {
62 |         out << '"';
63 | 
64 |         auto begin = std::begin(value);
65 |         auto end = std::end(value);
66 |         for (auto i = begin; i != end; ++i) {
67 |             charEscape(*i);
68 |         }
69 | 
70 |         out << '"';
71 |     }
72 | 
73 |     void identifierEscape(std::string &value) {
74 |         out << '`';
75 | 
76 |         auto begin = std::begin(value);
77 |         auto end = std::end(value);
78 |         for (auto i = begin; i != end; ++i) {
79 |             charEscape(*i);
80 |         }
81 | 
82 |         out << '`';
83 |     }
84 | 
85 | public:
86 |     VisitorMySQLBase(Out &_out): out{_out} {}
87 | };
88 | 
89 | }
90 | 


--------------------------------------------------------------------------------
/reflection++/visitor/strtree.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "../visitor.hpp"
  4 | #include "../accessor.hpp"
  5 | 
  6 | #include <sstream>
  7 | #include <string>
  8 | #include <memory>
  9 | #include <array>
 10 | #include <deque>
 11 | #include <forward_list>
 12 | #include <list>
 13 | #include <vector>
 14 | #include <map>
 15 | #include <unordered_map>
 16 | 
 17 | namespace rpp {
 18 | 
 19 | // read value from a tree of strings
 20 | template <class Node, class Stream = std::istringstream, bool strict = true>
 21 | struct VisitorIStrTree: public VisitorBase<void> {
 22 | private:
 23 |     Node &node;
 24 | 
 25 | public:
 26 |     VisitorIStrTree(Node &_node): node{_node} {}
 27 | 
 28 |     template <class T>
 29 |     void visit(T &value) {
 30 |         Stream buf{node};
 31 | 
 32 |         buf >> value;
 33 | 
 34 |         if (!buf.eof()) {
 35 |             throw Exception{};
 36 |         }
 37 |     }
 38 | 
 39 |     template <class... Args>
 40 |     void visit(std::basic_string<Args...> &value) { // TODO
 41 |         value = node;
 42 |     }
 43 | 
 44 |     // pointer
 45 | 
 46 |     template <class Accessor, class T>
 47 |     void into(Accessor &accessor, std::shared_ptr<T> &value) {
 48 |         if (!value) {
 49 |             value = new T{}; // TODO: argument T?
 50 |         }
 51 | 
 52 |         accessor.doMemberVisit(*this, *value);
 53 |     }
 54 | 
 55 |     template <class Accessor, class T>
 56 |     void into(Accessor &accessor, std::weak_ptr<T> &value) {
 57 |         if (!value) {
 58 |             value = new T{}; // TODO: argument T?
 59 |         }
 60 | 
 61 |         accessor.doMemberVisit(*this, *value);
 62 |     }
 63 | 
 64 |     template <class Accessor, class T, class... Args>
 65 |     void into(Accessor &accessor, std::unique_ptr<T, Args...> &value) {
 66 |         if (!value) {
 67 |             value = std::unique_ptr<T, Args...>{new T{}}; // TODO: argument T?
 68 |         }
 69 | 
 70 |         accessor.doMemberVisit(*this, *value);
 71 |     }
 72 | 
 73 |     template <class Accessor, class T>
 74 |     void into(Accessor &accessor, T *&value) {
 75 |         if (!value) {
 76 |             value = new T{};
 77 |         }
 78 | 
 79 |         accessor.doMemberVisit(*this, *value);
 80 |     }
 81 | 
 82 |     // array
 83 | 
 84 |     template <class Accessor, class T, rpp_size_t size>
 85 |     void into(Accessor &accessor, T (&value)[size]) {
 86 |         // this->visitArr(accessor, value); // TODO
 87 |         static_cast<void>(accessor);
 88 |         static_cast<void>(value);
 89 |     }
 90 | 
 91 |     template <class Accessor, class T, rpp_size_t size>
 92 |     void into(Accessor &accessor, std::array<T, size> &value) {
 93 |         // this->visitArr(accessor, value); // TODO
 94 |         static_cast<void>(accessor);
 95 |         static_cast<void>(value);
 96 |     }
 97 | 
 98 |     template <class Accessor, class... Args>
 99 |     void into(Accessor &accessor, std::deque<Args...> &value) {
100 |         // this->visitArr(accessor, value); // TODO
101 |         static_cast<void>(accessor);
102 |         static_cast<void>(value);
103 |     }
104 | 
105 |     template <class Accessor, class... Args>
106 |     void into(Accessor &accessor, std::forward_list<Args...> &value) {
107 |         // this->visitArr(accessor, value); // TODO
108 |         static_cast<void>(accessor);
109 |         static_cast<void>(value);
110 |     }
111 | 
112 |     template <class Accessor, class... Args>
113 |     void into(Accessor &accessor, std::list<Args...> &value) {
114 |         // this->visitArr(accessor, value); // TODO
115 |         static_cast<void>(accessor);
116 |         static_cast<void>(value);
117 |     }
118 | 
119 |     template <class Accessor, class... Args>
120 |     void into(Accessor &accessor, std::vector<Args...> &value) {
121 |         // this->visitArr(accessor, value); // TODO
122 |         static_cast<void>(accessor);
123 |         static_cast<void>(value);
124 |     }
125 | 
126 |     // map
127 | 
128 |     template <class Accessor, class... Args>
129 |     void into(Accessor &accessor, std::map<Args...> &value) {
130 |         // this->visitMap(accessor, value); // TODO
131 |         static_cast<void>(accessor);
132 |         static_cast<void>(value);
133 |     }
134 | 
135 |     template <class Accessor, class... Args>
136 |     void into(Accessor &accessor, std::unordered_map<Args...> &value) {
137 |         // this->visitMap(accessor, value); // TODO
138 |         static_cast<void>(accessor);
139 |         static_cast<void>(value);
140 |     }
141 | 
142 |     // handle different types of accessors
143 | 
144 |     template <class... Args>
145 |     void operator()(AccessorSimple<Args...> &accessor) {
146 |         visit(accessor());
147 |     }
148 | 
149 |     template <class... Args>
150 |     void operator()(AccessorObject<Args...> &accessor) {
151 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
152 |             VisitorIStrTree<
153 |                 decltype(node[""]), Stream
154 |             > child{
155 |                 strict ? node.at(accessor.getMemberName(i))
156 |                        : node[accessor.getMemberName(i)]
157 |             };
158 | 
159 |             accessor.doMemberVisit(child, i);
160 |         }
161 |     }
162 | 
163 |     template <class... Args>
164 |     void operator()(AccessorDynamic<Args...> &accessor) {
165 |         into(accessor, accessor());
166 |     }
167 | };
168 | 
169 | // build a tree of strings
170 | template <class Node, class Stream = std::ostringstream>
171 | struct VisitorOStrTree: public VisitorBase<void> {
172 | private:
173 |     Node &node;
174 | 
175 | public:
176 |     VisitorOStrTree(Node &_node): node{_node} {}
177 | 
178 |     template <class T>
179 |     void visit(T &value) {
180 |         Stream buf;
181 | 
182 |         buf << value;
183 |         node = buf.str();
184 |     }
185 | 
186 |     template <class... Args>
187 |     void visit(const std::basic_string<Args...> &value) { // TODO
188 |         node = value;
189 |     }
190 | 
191 |     // pointer
192 | 
193 |     template <class Accessor, class... Args>
194 |     void into(Accessor &accessor, std::shared_ptr<Args...> &value) {
195 |         if (value) {
196 |             accessor.doMemberVisit(*this, *value);
197 |         }
198 |     }
199 | 
200 |     template <class Accessor, class... Args>
201 |     void into(Accessor &accessor, std::weak_ptr<Args...> &value) {
202 |         if (value) {
203 |             accessor.doMemberVisit(*this, *value);
204 |         }
205 |     }
206 | 
207 |     template <class Accessor, class... Args>
208 |     void into(Accessor &accessor, std::unique_ptr<Args...> &value) {
209 |         if (value) {
210 |             accessor.doMemberVisit(*this, *value);
211 |         }
212 |     }
213 | 
214 |     template <class Accessor, class T>
215 |     void into(Accessor &accessor, T *&value) {
216 |         if (value) {
217 |             accessor.doMemberVisit(*this, *value);
218 |         }
219 |     }
220 | 
221 |     // array
222 | 
223 |     template <class Accessor, class T, rpp_size_t size>
224 |     void into(Accessor &accessor, T (&value)[size]) {
225 |         // this->visitArr(accessor, value); // TODO
226 |         static_cast<void>(accessor);
227 |         static_cast<void>(value);
228 |     }
229 | 
230 |     template <class Accessor, class T, rpp_size_t size>
231 |     void into(Accessor &accessor, std::array<T, size> &value) {
232 |         // this->visitArr(accessor, value); // TODO
233 |         static_cast<void>(accessor);
234 |         static_cast<void>(value);
235 |     }
236 | 
237 |     template <class Accessor, class... Args>
238 |     void into(Accessor &accessor, std::deque<Args...> &value) {
239 |         // this->visitArr(accessor, value); // TODO
240 |         static_cast<void>(accessor);
241 |         static_cast<void>(value);
242 |     }
243 | 
244 |     template <class Accessor, class... Args>
245 |     void into(Accessor &accessor, std::forward_list<Args...> &value) {
246 |         // this->visitArr(accessor, value); // TODO
247 |         static_cast<void>(accessor);
248 |         static_cast<void>(value);
249 |     }
250 | 
251 |     template <class Accessor, class... Args>
252 |     void into(Accessor &accessor, std::list<Args...> &value) {
253 |         // this->visitArr(accessor, value); // TODO
254 |         static_cast<void>(accessor);
255 |         static_cast<void>(value);
256 |     }
257 | 
258 |     template <class Accessor, class... Args>
259 |     void into(Accessor &accessor, std::vector<Args...> &value) {
260 |         // this->visitArr(accessor, value); // TODO
261 |         static_cast<void>(accessor);
262 |         static_cast<void>(value);
263 |     }
264 | 
265 |     // map
266 | 
267 |     template <class Accessor, class... Args>
268 |     void into(Accessor &accessor, std::map<Args...> &value) {
269 |         // this->visitMap(accessor, value); // TODO
270 |         static_cast<void>(accessor);
271 |         static_cast<void>(value);
272 |     }
273 | 
274 |     template <class Accessor, class... Args>
275 |     void into(Accessor &accessor, std::unordered_map<Args...> &value) {
276 |         // this->visitMap(accessor, value); // TODO
277 |         static_cast<void>(accessor);
278 |         static_cast<void>(value);
279 |     }
280 | 
281 |     // handle different types of accessors
282 | 
283 |     template <class... Args>
284 |     void operator()(AccessorSimple<Args...> &accessor) {
285 |         visit(accessor());
286 |     }
287 | 
288 |     template <class... Args>
289 |     void operator()(AccessorObject<Args...> &accessor) {
290 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
291 |             VisitorOStrTree<
292 |                 decltype(node[""]), Stream
293 |             > child{
294 |                 node[accessor.getMemberName(i)]
295 |             };
296 | 
297 |             accessor.doMemberVisit(child, i);
298 |         }
299 |     }
300 | 
301 |     template <class... Args>
302 |     void operator()(AccessorDynamic<Args...> &accessor) {
303 |         into(accessor, accessor());
304 |     }
305 | };
306 | 
307 | }
308 | 


--------------------------------------------------------------------------------
/reflection++/visitor_chain.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "traits.hpp"
 4 | #include "visitor.hpp"
 5 | 
 6 | namespace rpp {
 7 | 
 8 | // the abstract tail of the visitor chain
 9 | struct VisitorTail final {
10 |     // compile-time only
11 |     VisitorTail() = delete;
12 | };
13 | 
14 | // register a visitor class into the visitor chain
15 | // helper macros
16 | #define RPP_VISITOR_REG_UNIQUE_2(Counter, ...) \
17 |     namespace visitor_chain { \
18 |         template <class Last> \
19 |         Last trace_##Counter(Here, rpp::VisitorTail &, Last &); \
20 |         \
21 |         template <class T, class Last> \
22 |         auto trace_##Counter(Here, T &value, Last &last) -> decltype( \
23 |             trace_##Counter(here, next(here, value), value) \
24 |         ); \
25 |         \
26 |         rpp::GetRef<__VA_ARGS__> next( \
27 |             Here, \
28 |             decltype( \
29 |                 trace_##Counter(here, next(here, here), here) \
30 |             ) & \
31 |         ); \
32 |     }
33 | #define RPP_VISITOR_REG_UNIQUE_1(...) \
34 |     RPP_VISITOR_REG_UNIQUE_2(__VA_ARGS__)
35 | // the main macro
36 | #define RPP_VISITOR_REG(...) \
37 |     RPP_VISITOR_REG_UNIQUE_1(__COUNTER__, __VA_ARGS__)
38 | 
39 | // pass all visitor classes in the chain to a type list and create a type alias
40 | // using Type = TypeList<Visitor1, Visitor2, ...>
41 | #define RPP_VISITOR_COLLECT(Type) \
42 |     namespace visitor_chain { \
43 |         template <class... Args> \
44 |         rpp::TypeList<Args...> trace2_##Type(Here, rpp::VisitorTail &, rpp::TypeList<Args...>); \
45 |         \
46 |         template <class T, class... Args> \
47 |         auto trace2_##Type(Here, T &value, rpp::TypeList<Args...>) -> decltype( \
48 |             trace2_##Type( \
49 |                 here, \
50 |                 next(here, value), \
51 |                 rpp::TypeList<Args...>::template Append<T>::instance() \
52 |             ) \
53 |         ); \
54 |         \
55 |         using Type = \
56 |             decltype( \
57 |                 trace2_##Type( \
58 |                     here, \
59 |                     next(here, here), \
60 |                     rpp::TypeList<>::instance() \
61 |                 ) \
62 |             ); \
63 |     } \
64 |     \
65 |     using Type = visitor_chain::Type;
66 | 
67 | // enable the visitor chain in the current namespace
68 | #define RPP_VISITOR_CHAIN_INIT() \
69 |     namespace visitor_chain { \
70 |         /* an empty object to control argument-dependent lookup */ \
71 |         /* and provide a head of the visitor chain */ \
72 |         static constexpr struct Here final { \
73 |             Here() = delete; \
74 |         } here{}; \
75 |         \
76 |         /* an abstract function to infer the next member of the visitor chain */ \
77 |         rpp::VisitorTail &next(...); \
78 |         \
79 |         /* call next with VisitorTail is not allowed */ \
80 |         void next(Here, rpp::VisitorTail &) = delete; \
81 |     }
82 | 
83 | RPP_VISITOR_CHAIN_INIT()
84 | 
85 | }
86 | 


--------------------------------------------------------------------------------
/tests/common.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <type_traits>
  4 | #include <iostream>
  5 | 
  6 | #include "../reflection++/visitor_chain.hpp"
  7 | #include "../reflection++/visitor/basic.hpp"
  8 | #include "../reflection++/visitor/strtree.hpp"
  9 | #include "../reflection++/visitor/json.hpp"
 10 | #include "../reflection++/visitor/bson.hpp"
 11 | #include "../reflection++/visitor/bson_view.hpp"
 12 | #include "../reflection++/visitor/mysql.hpp"
 13 | #include "../reflection++/meta.hpp"
 14 | 
 15 | namespace rpp_another_namespace {
 16 | 
 17 | RPP_ACCESSOR_INFER_INIT()
 18 | 
 19 | struct TestStruct {
 20 |     int member1;
 21 |     float member2;
 22 | };
 23 | 
 24 | struct TestStruct2: public TestStruct {
 25 |     char member3;
 26 |     static int member4;
 27 |     TestStruct member5;
 28 | 
 29 |     TestStruct2(int a, char b, int c):
 30 |         TestStruct{a, a + 1.0f}, member3{b}, member5{c, c + 1.0f} {}
 31 | };
 32 | 
 33 | struct TestStruct3 {
 34 |     static int a;
 35 |     double b{2};
 36 | 
 37 |     TestStruct3() = default;
 38 | };
 39 | 
 40 | struct TestStruct4 {
 41 |     const double b{2.1};
 42 | };
 43 | 
 44 | struct TestStruct5: public TestStruct3, public TestStruct4 {
 45 |     TestStruct4 c[2];
 46 |     std::string d{"string\t字符串\n"};
 47 |     std::vector<float> e{5, 5.1, 5.2};
 48 |     std::map<std::string, unsigned> f{{"item1", 6}, {"item2", 7}};
 49 |     int g[3]{8, 9, 10};
 50 |     bool h{false};
 51 |     static constexpr bool i{true};
 52 |     std::unique_ptr<bool> j[2]{nullptr, nullptr};
 53 |     char k[6]{'t', 'e', 's', 't', 0, 0};
 54 | 
 55 |     TestStruct5() = default;
 56 | };
 57 | 
 58 | struct TestStruct4m {
 59 |     float b;
 60 | };
 61 | 
 62 | struct TestStruct5m: public TestStruct3, public TestStruct4m {
 63 |     TestStruct4m c[2];
 64 |     std::string d;
 65 |     std::array<double, 3> e;
 66 |     std::unordered_map<std::string, unsigned long> f{};
 67 |     float g[3];
 68 |     int h;
 69 |     unsigned i;
 70 |     std::unique_ptr<bool> j[2]{nullptr, nullptr};
 71 |     std::string k[6];
 72 | 
 73 |     TestStruct5m() = default;
 74 | };
 75 | 
 76 | static char value_ts6_c[32]{"hello!"};
 77 | 
 78 | struct TestStruct6 {
 79 |     static int a;
 80 |     double b{200};
 81 |     char *c{value_ts6_c};
 82 | 
 83 |     TestStruct6() = default;
 84 | };
 85 | 
 86 | template <class T>
 87 | struct TestStruct7: public TestStruct6 {
 88 |     T d;
 89 | 
 90 |     TestStruct7() = default;
 91 | };
 92 | 
 93 | template <class T, size_t size>
 94 | RPP_TYPE_DYNAMIC_GENERIC(T, T [size])
 95 | template <class T, size_t size>
 96 | RPP_TYPE_DYNAMIC_GENERIC(T, std::array<T, size>)
 97 | template <class T, class... Args>
 98 | RPP_TYPE_DYNAMIC_GENERIC(T, std::vector<T, Args...>)
 99 | template <class Key, class T, class... Args>
100 | RPP_TYPE_DYNAMIC_GENERIC(T, std::map<Key, T, Args...>)
101 | template <class Key, class T, class... Args>
102 | RPP_TYPE_DYNAMIC_GENERIC(T, std::unordered_map<Key, T, Args...>)
103 | template <class T, class... Args>
104 | RPP_TYPE_DYNAMIC_GENERIC(T, std::unique_ptr<T, Args...>)
105 | 
106 | RPP_TYPE_OBJECT(
107 |     __(member1)
108 |     __(member2, MEMBER), // the same as __(member2)
109 |     TestStruct
110 | )
111 | 
112 | RPP_TYPE_OBJECT(
113 |     __(TestStruct, BASE)
114 |     __(member3)
115 |     __(member4, REF)
116 |     __(member5),
117 |     TestStruct2
118 | )
119 | 
120 | RPP_TYPE_OBJECT(
121 |     __(a, REF)
122 |     __(b),
123 |     TestStruct3
124 | )
125 | 
126 | RPP_TYPE_OBJECT(
127 |     __(b),
128 |     TestStruct4
129 | )
130 | 
131 | RPP_TYPE_OBJECT(
132 |     __(TestStruct3, BASE)
133 |     __(TestStruct4, BASE_INLINE)
134 |     __(c)
135 |     __(d)
136 |     __(e)
137 |     __(f)
138 |     __(g)
139 |     __(h)
140 |     __(i, CONST)
141 |     __(j)
142 |     __(k),
143 |     TestStruct5
144 | )
145 | 
146 | RPP_TYPE_OBJECT(
147 |     __(b),
148 |     TestStruct4m
149 | )
150 | 
151 | RPP_TYPE_OBJECT(
152 |     __(TestStruct3, BASE)
153 |     __(TestStruct4m, BASE_INLINE)
154 |     __(c)
155 |     __(d)
156 |     __(e)
157 |     __(f)
158 |     __(g)
159 |     __(h)
160 |     __(i)
161 |     __(j)
162 |     __(k),
163 |     TestStruct5m
164 | )
165 | 
166 | RPP_TYPE_OBJECT(
167 |     __(a, REF)
168 |     __(b)
169 |     __(c),
170 |     TestStruct6
171 | )
172 | 
173 | template <class T>
174 | RPP_TYPE_OBJECT_GENERIC(
175 |     __(TestStruct6, BASE)
176 |     __(d),
177 |     TestStruct7<T>
178 | )
179 | 
180 | }
181 | 


--------------------------------------------------------------------------------
/tests/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.hpp"
 2 | 
 3 | namespace rpp_another_namespace {
 4 | 
 5 | int TestStruct2::member4{4};
 6 | int TestStruct3::a{1};
 7 | int TestStruct6::a{100};
 8 | 
 9 | }
10 | 
11 | int main() {
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/main_dup.cpp:
--------------------------------------------------------------------------------
1 | #include "common.hpp"
2 | 


--------------------------------------------------------------------------------
/tests/meta.cpp:
--------------------------------------------------------------------------------
  1 | #include "common.hpp"
  2 | 
  3 | namespace rpp {
  4 | 
  5 | struct Visitor4: public VisitorBase<> {
  6 |     Visitor4() = default;
  7 |     Visitor4(Visitor4 &&) = delete;
  8 |     Visitor4(const Visitor4 &) = delete;
  9 | 
 10 |     long misc1;
 11 |     std::string misc2;
 12 | 
 13 |     void visit(int &value) {
 14 |         std::cerr << "int(" << value << ") ";
 15 |     }
 16 | 
 17 |     void visit(char &value) {
 18 |         std::cerr << "char(" << value << ") ";
 19 |         value += 1;
 20 |     }
 21 | 
 22 |     void visit(bool &value) {
 23 |         std::cerr << "bool(" << value << ") ";
 24 |     }
 25 | 
 26 |     void visit(float &value) {
 27 |         std::cerr << "float(" << value << ") ";
 28 |     }
 29 | 
 30 |     template <class T>
 31 |     void visit(const HolderType<T> &) {
 32 |         std::cerr << "type(" << typeid(T).name() << ") ";
 33 |     }
 34 | 
 35 |     template <class... Args>
 36 |     void operator()(AccessorSimple<Args...> &accessor) {
 37 |         visit(accessor());
 38 |     }
 39 | 
 40 |     template <class... Args>
 41 |     void operator()(AccessorObject<Args...> &accessor) {
 42 |         std::cerr << "object( ";
 43 | 
 44 |         for (rpp_size_t i = 0; i < accessor.size(); ++i) {
 45 |             accessor.doMemberVisit(*this, i);
 46 |         }
 47 | 
 48 |         std::cerr << ") ";
 49 |     }
 50 | };
 51 | 
 52 | struct Visitor5: public VisitorBase<const char *> {
 53 |     template <class T>
 54 |     const char *visit(T &value) {
 55 |         return typeid(value).name();
 56 |     }
 57 | 
 58 |     template <class Accessor>
 59 |     const char *operator()(Accessor &accessor) {
 60 |         return visit(accessor());
 61 |     }
 62 | };
 63 | 
 64 | RPP_VISITOR_REG(Visitor4)
 65 | RPP_VISITOR_REG(Visitor5)
 66 | RPP_VISITOR_COLLECT(VisitorAll3)
 67 | 
 68 | using Accessor1 = AccessorSimple<
 69 |     RPP_HOLDER_LOCAL(int)
 70 | >;
 71 | 
 72 | static_assert(std::is_same<
 73 |     Accessor1,
 74 |     AccessorSimple<
 75 |         HolderLocal<int>
 76 |     >
 77 | >(), "");
 78 | 
 79 | char value3{'C'};
 80 | 
 81 | }
 82 | 
 83 | namespace rpp_another_namespace {
 84 | 
 85 | using Accessor1 = rpp::Accessor1;
 86 | using Accessor2 = RPP_ACCESSOR_AS(LOCAL, char);
 87 | using Accessor3 = RPP_ACCESSOR_AS(REF, rpp::value3);
 88 | using Accessor4 = RPP_ACCESSOR_AS(DYNAMIC, char);
 89 | 
 90 | using Accessor5m1 = RPP_ACCESSOR_AS(MEMBER, TestStruct, member1);
 91 | using Accessor5m2 = RPP_ACCESSOR_AS(MEMBER, TestStruct, member2);
 92 | 
 93 | using Accessor5 = RPP_ACCESSOR_AS(LOCAL, TestStruct);
 94 | using Accessor6 = Accessor5::Type;
 95 | 
 96 | using Accessor7m3 = RPP_ACCESSOR_AS(MEMBER, TestStruct2, member3);
 97 | using Accessor7m4 = RPP_ACCESSOR_AS(REF, TestStruct2::member4);
 98 | using Accessor7m5 = RPP_ACCESSOR_AS(MEMBER, TestStruct2, member5);
 99 | 
100 | using Accessor7 = RPP_ACCESSOR_AS(LOCAL, TestStruct2);
101 | 
102 | static_assert(
103 |     std::is_same<
104 |         Accessor3,
105 |         rpp::AccessorSimple<
106 |             rpp::HolderRef<char, rpp::value3>
107 |         >
108 |     >(), ""
109 | );
110 | 
111 | static_assert(
112 |     std::is_same<
113 |         Accessor5m1,
114 |         rpp::AccessorSimple<
115 |             rpp::HolderMember<TestStruct, int, &TestStruct::member1>
116 |         >
117 |     >(), ""
118 | );
119 | 
120 | static_assert(
121 |     std::is_same<
122 |         Accessor5m1::Type,
123 |         rpp::AccessorSimple<
124 |             rpp::HolderType<int &>
125 |         >
126 |     >(), ""
127 | );
128 | 
129 | static_assert(
130 |     std::is_same<
131 |         Accessor5m2,
132 |         rpp::AccessorSimple<
133 |             rpp::HolderMember<TestStruct, float, &TestStruct::member2>
134 |         >
135 |     >(), ""
136 | );
137 | 
138 | static_assert(
139 |     std::is_same<
140 |         Accessor5,
141 |         rpp::AccessorObject<
142 |             rpp::HolderLocal<TestStruct>,
143 |             rpp::TypeList<
144 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member1")>,
145 |                 Accessor5m1,
146 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member2")>,
147 |                 Accessor5m2
148 |             >
149 |         >
150 |     >(), ""
151 | );
152 | 
153 | static_assert(
154 |     std::is_same<
155 |         Accessor6,
156 |         rpp::AccessorObject<
157 |             rpp::HolderType<TestStruct &>,
158 |             rpp::TypeList<
159 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member1")>,
160 |                 Accessor5m1::Type,
161 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member2")>,
162 |                 Accessor5m2::Type
163 |             >
164 |         >
165 |     >(), ""
166 | );
167 | 
168 | static_assert(
169 |     std::is_same<
170 |         Accessor7,
171 |         rpp::AccessorObject<
172 |             rpp::HolderLocal<TestStruct2>,
173 |             rpp::TypeList<
174 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("TestStruct")>,
175 |                 rpp::AccessorObject<
176 |                     rpp::HolderDynamic<TestStruct>,
177 |                     rpp::TypeList<
178 |                         rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member1")>,
179 |                         Accessor5m1,
180 |                         rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member2")>,
181 |                         Accessor5m2
182 |                     >
183 |                 >,
184 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member3")>,
185 |                 Accessor7m3,
186 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member4")>,
187 |                 Accessor7m4,
188 |                 rpp::HolderConst<const char (&)[], RPP_STATIC_STR("member5")>,
189 |                 Accessor7m5
190 |             >
191 |         >
192 |     >(), ""
193 | );
194 | 
195 | static const int test_meta = []() {
196 |     std::cerr << "======== test: " << __FILE__ << " ========" << std::endl;
197 | 
198 |     rpp::MetaImpl<
199 |         RPP_HOLDER_STR("value1"),
200 |         Accessor1,
201 |         rpp::VisitorAll3
202 |     > meta1{0};
203 |     rpp::MetaImpl<
204 |         RPP_HOLDER_STR("value2"),
205 |         Accessor2,
206 |         rpp::VisitorAll3
207 |     > meta2{'A'};
208 |     rpp::MetaImpl<
209 |         RPP_HOLDER_STR("value3"),
210 |         Accessor3,
211 |         rpp::VisitorAll3
212 |     > meta3;
213 |     rpp::MetaImpl<
214 |         RPP_HOLDER_STR("value4"),
215 |         Accessor4,
216 |         rpp::VisitorAll3
217 |     > meta4{rpp::value3};
218 |     rpp::MetaImpl<
219 |         RPP_HOLDER_STR("value5"),
220 |         Accessor5,
221 |         rpp::VisitorAll3
222 |     > meta5{TestStruct{1, 1.5}};
223 |     rpp::MetaImpl<
224 |         RPP_HOLDER_STR("value6"),
225 |         Accessor6,
226 |         rpp::VisitorAll3
227 |     > meta6;
228 |     rpp::MetaImpl<
229 |         RPP_HOLDER_STR("value7"),
230 |         Accessor7,
231 |         rpp::VisitorAll3
232 |     > meta7{TestStruct2{1, '3', 5}};
233 | 
234 |     std::vector<rpp::MetaBase<rpp::VisitorAll3> *> metalist{
235 |         &meta1, &meta2, &meta3, &meta4, &meta5, &meta6, &meta7
236 |     };
237 | 
238 |     rpp::Visitor4 v4;
239 |     rpp::Visitor5 v5;
240 | 
241 |     for (rpp::MetaBase<rpp::VisitorAll3> *meta: metalist) {
242 |         std::cerr << meta->getName() << "\t";
243 |         // std::cerr << meta->getTypeInfo().name() << ", ";
244 |         // std::cerr << meta->getPointer() << " - ";
245 |         meta->doVisit(v4);
246 |         std::cerr << std::endl;
247 |         std::cerr << "\ttype " << meta->doVisit(v5);
248 |         std::cerr << std::endl;
249 |     }
250 | 
251 |     std::cerr << "sizeof(Accessor):";
252 |     std::cerr << " " << sizeof(Accessor1);
253 |     std::cerr << " " << sizeof(Accessor2);
254 |     std::cerr << " " << sizeof(Accessor3);
255 |     std::cerr << " " << sizeof(Accessor4);
256 |     std::cerr << " " << sizeof(Accessor5);
257 |     std::cerr << " " << sizeof(Accessor6);
258 |     std::cerr << " " << sizeof(Accessor7);
259 |     std::cerr << std::endl;
260 | 
261 |     std::cerr << "sizeof(meta):";
262 |     std::cerr << " " << sizeof(meta1);
263 |     std::cerr << " " << sizeof(meta2);
264 |     std::cerr << " " << sizeof(meta3);
265 |     std::cerr << " " << sizeof(meta4);
266 |     std::cerr << " " << sizeof(meta5);
267 |     std::cerr << " " << sizeof(meta6);
268 |     std::cerr << " " << sizeof(meta7);
269 |     std::cerr << std::endl;
270 | 
271 |     return 0;
272 | }();
273 | 
274 | }
275 | 


--------------------------------------------------------------------------------
/tests/static_str.cpp:
--------------------------------------------------------------------------------
 1 | #include <type_traits>
 2 | 
 3 | #include "../reflection++/static_str.hpp"
 4 | 
 5 | namespace rpp_another_namespace {
 6 | 
 7 | static_assert(rpp::strIndex("abc", 1) == 'b', "");
 8 | static_assert(rpp::strIndex("abc", 3) == '\0', "");
 9 | static_assert(rpp::strIndex("abc", 5) == '\0', "");
10 | 
11 | template <const char *str>
12 | struct SomeStrClass {};
13 | 
14 | SomeStrClass<RPP_STATIC_STR("abc")> some_str_object;
15 | 
16 | static_assert(std::is_same<
17 |     decltype(some_str_object),
18 |     SomeStrClass<rpp::StaticStr<
19 |         0, 'a', 'b', 'c'
20 |     >::str>
21 | >(), "");
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/visitor_bson.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.hpp"
 2 | 
 3 | #include <bsoncxx/json.hpp>
 4 | 
 5 | namespace rpp_another_namespace {
 6 | 
 7 | static const int test_bson = []() {
 8 |     std::cerr << "======== test: " << __FILE__ << " ========" << std::endl;
 9 | 
10 |     // out
11 | 
12 |     RPP_META_LOCAL(
13 |         "value", TestStruct5,
14 |         rpp::TypeList<
15 |             rpp::VisitorBSON<>
16 |         >
17 |     ) meta1{TestStruct5{}};
18 | 
19 |     rpp::VisitorBSON<> doc{};
20 |     meta1.doVisit(doc);
21 | 
22 |     std::cerr << bsoncxx::to_json(doc) << std::endl;
23 | 
24 |     // in
25 | 
26 |     RPP_META_LOCAL(
27 |         "value", TestStruct5m,
28 |         rpp::TypeList<
29 |             rpp::VisitorBSON<>,
30 |             rpp::VisitorBSONView<>
31 |         >
32 |     ) meta2{TestStruct5m{}};
33 | 
34 |     rpp::VisitorBSONView<> view{bsoncxx::types::b_document{doc}};
35 |     meta2.doVisit(view);
36 | 
37 |     rpp::VisitorBSON<> doc2{};
38 |     meta2.doVisit(doc2);
39 | 
40 |     std::cerr << bsoncxx::to_json(doc2) << std::endl;
41 | 
42 |     return 0;
43 | }();
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/visitor_chain.cpp:
--------------------------------------------------------------------------------
 1 | #include <type_traits>
 2 | 
 3 | #include "../reflection++/visitor_chain.hpp"
 4 | 
 5 | namespace rpp {
 6 | 
 7 | struct Visitor1: public VisitorIgnoreBase<> {};
 8 | struct Visitor2: public VisitorIgnoreBase<> {};
 9 | namespace some_namespace {
10 |     struct Visitor3: public VisitorIgnoreBase<> {};
11 | }
12 | using Visitor3 = some_namespace::Visitor3;
13 | 
14 | RPP_VISITOR_COLLECT(VisitorAll1)
15 | 
16 | RPP_VISITOR_REG(Visitor1)
17 | RPP_VISITOR_REG(Visitor2)
18 | RPP_VISITOR_REG(Visitor3)
19 | 
20 | RPP_VISITOR_COLLECT(VisitorAll2)
21 | 
22 | static_assert(std::is_same<VisitorAll1, TypeList<>>(), "");
23 | static_assert(std::is_same<VisitorAll2, TypeList<
24 |     Visitor1, Visitor2, some_namespace::Visitor3
25 | >>(), "");
26 | 
27 | }
28 | 
29 | namespace rpp_another_namespace {
30 | 
31 | RPP_VISITOR_CHAIN_INIT()
32 | 
33 | using Visitor1 = rpp::Visitor1;
34 | struct Visitor2: public rpp::VisitorIgnoreBase<> {};
35 | 
36 | RPP_VISITOR_REG(Visitor1)
37 | RPP_VISITOR_REG(Visitor2)
38 | 
39 | RPP_VISITOR_COLLECT(VisitorAll1)
40 | 
41 | static_assert(std::is_same<VisitorAll1, rpp::TypeList<
42 |     rpp::Visitor1, Visitor2
43 | >>(), "");
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/visitor_json.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.hpp"
 2 | 
 3 | namespace rpp_another_namespace {
 4 | 
 5 | static const int test_json = []() {
 6 |     std::cerr << "======== test: " << __FILE__ << " ========" << std::endl;
 7 | 
 8 |     RPP_META_LOCAL(
 9 |         "value", TestStruct5,
10 |         rpp::TypeList<rpp::VisitorJSON<>>
11 |     ) meta{TestStruct5{}};
12 | 
13 |     rpp::VisitorJSON<> v{std::cerr};
14 |     meta.doVisit(v);
15 | 
16 |     std::cerr << std::endl;
17 | 
18 |     return 0;
19 | }();
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/visitor_strtree.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.hpp"
 2 | 
 3 | namespace rpp_another_namespace {
 4 | 
 5 | static const int test_strtree = []() {
 6 |     std::cerr << "======== test: " << __FILE__ << " ========" << std::endl;
 7 | 
 8 |     // out
 9 | 
10 |     using Root = std::unordered_map<
11 |         std::string,
12 |         std::map<
13 |             std::string,
14 |             std::string
15 |         >
16 |     >;
17 | 
18 |     RPP_META_LOCAL(
19 |         "value", TestStruct7<TestStruct6>,
20 |         rpp::TypeList<
21 |             rpp::VisitorIStrTree<Root &>,
22 |             rpp::VisitorOStrTree<Root &>
23 |         >
24 |     ) meta{TestStruct7<TestStruct6>{}};
25 | 
26 |     Root root1;
27 |     Root root2;
28 | 
29 |     rpp::VisitorOStrTree<Root &> v1{root1};
30 |     meta.doVisit(v1);
31 | 
32 |     char tag = '0';
33 |     for (auto &i: root1) {
34 |         std::cerr << i.first << ": " << std::endl;
35 |         for (auto &j: i.second) {
36 |             std::cerr << "    " << j.first << ": " << j.second << std::endl;
37 |             j.second += tag;
38 |             ++tag;
39 |         }
40 |     }
41 | 
42 |     // in
43 | 
44 |     rpp::VisitorIStrTree<Root &> v2{root1};
45 |     meta.doVisit(v2);
46 | 
47 |     rpp::VisitorOStrTree<Root &> v3{root2};
48 |     meta.doVisit(v3);
49 | 
50 |     for (auto &i: root2) {
51 |         std::cerr << i.first << ": " << std::endl;
52 |         for (auto &j: i.second) {
53 |             std::cerr << "    " << j.first << ": " << j.second << std::endl;
54 |         }
55 |     }
56 | 
57 |     return 0;
58 | }();
59 | 
60 | }
61 | 


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