├── .gitignore
├── include
    └── Reflectable
    │   ├── reflectable.h
    │   ├── for_each.h
    │   └── tagged_tuple.h
├── README.md
├── Reflectable.cbp
└── main.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | bin/*
2 | obj/*
3 | *.layout
4 | *.depend


--------------------------------------------------------------------------------
/include/Reflectable/reflectable.h:
--------------------------------------------------------------------------------
 1 | #ifndef REFLECTABLE_REFLECTABLE_H_INCLUDED
 2 | #define REFLECTABLE_REFLECTABLE_H_INCLUDED
 3 | 
 4 | #include "Reflectable/tagged_tuple.h"
 5 | #include "Reflectable/for_each.h"
 6 | 
 7 | template <typename ...Args>
 8 | class Reflectable : public tagged_tuple<Args...>
 9 | {
10 |     public:
11 |         template <typename FuncT>
12 |         void iterate(const FuncT& f)
13 |         {
14 |             for_each(*this, f);
15 |         }
16 | };
17 | 
18 | #endif // REFLECTABLE_REFLECTABLE_H_INCLUDED
19 | 


--------------------------------------------------------------------------------
/include/Reflectable/for_each.h:
--------------------------------------------------------------------------------
 1 | #ifndef REFLECTABLE_FOR_EACH_H_INCLUDED
 2 | #define REFLECTABLE_FOR_EACH_H_INCLUDED
 3 | 
 4 | #include <tuple>
 5 | 
 6 | // ************************************************************************************************
 7 | // Code stolen from: http://stackoverflow.com/a/6894436
 8 | 
 9 | template<std::size_t I = 0, typename FuncT, typename... Tp>
10 | inline typename std::enable_if<I == sizeof...(Tp), void>::type
11 | for_each(std::tuple<Tp...> &, FuncT) // Unused arguments are given no names.
12 | {
13 | }
14 | 
15 | template<std::size_t I = 0, typename FuncT, typename... Tp>
16 | inline typename std::enable_if<I < sizeof...(Tp), void>::type
17 | for_each(std::tuple<Tp...>& t, FuncT f)
18 | {
19 |     f(std::get<I>(t));
20 |     for_each<I + 1, FuncT, Tp...>(t, f);
21 | }
22 | 
23 | #endif // REFLECTABLE_FOR_EACH_H_INCLUDED
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Reflectable #
 2 | 
 3 | A C++11 header only library built from code stolen from around the internet to allow compile-time reflection.
 4 | 
 5 | This whole thing is build on std::tuple.
 6 | 
 7 | ### Much Thanks ###
 8 | 
 9 | Much thanks to the template wizards who really wrote this code. All I did was steal their code and glue it together :)
10 | 
11 | [Iterating through a std::tuple](http://stackoverflow.com/a/6894436 "Iterating through a std::tuple")
12 | 
13 | [Tagged tuples (The real heart and soul)](http://stackoverflow.com/a/13066078 "Tagged tuples (The real heart and soul)")
14 | 
15 | ### Limitations ###
16 | 
17 | Member variable names use structs as tags for the compiler. This means that no other symbols can conflict with the variable names in your reflectable objects, which sucks. You can, however, reuse variable names across multiple reflectable objects.
18 | 
19 | ### Benchmarks ###
20 | 
21 | Without compiler optimizations
22 | 	
23 | 	Raw for loop: 0.53s
24 | 	Regular access: 0.597s
25 | 	Reflectable access: 3.782s
26 | 	Reflectable with reference access: 0.559s
27 | 
28 | With compiler optimizations (-O)
29 | 
30 | 	Raw for loop: 0.084s
31 | 	Regular access: 0.086s
32 | 	Reflectable access: 0.084s
33 | 	Reflectable with reference access: 0.104s
34 | 
35 | With compiler optimizations (-O1)
36 | 
37 | 	Raw for loop: 0.085s
38 | 	Regular access: 0.085s
39 | 	Reflectable access: 0.085s
40 | 	Reflectable with reference access: 0.104s
41 | 


--------------------------------------------------------------------------------
/Reflectable.cbp:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
 2 | <CodeBlocks_project_file>
 3 | 	<FileVersion major="1" minor="6" />
 4 | 	<Project>
 5 | 		<Option title="Reflectable" />
 6 | 		<Option pch_mode="2" />
 7 | 		<Option compiler="gcc" />
 8 | 		<Build>
 9 | 			<Target title="Debug">
10 | 				<Option output="bin/Debug/TupleFunTimes" prefix_auto="1" extension_auto="1" />
11 | 				<Option working_dir="bin/Debug/" />
12 | 				<Option object_output="obj/Debug/" />
13 | 				<Option type="1" />
14 | 				<Option compiler="gcc" />
15 | 				<Compiler>
16 | 					<Add option="-g" />
17 | 				</Compiler>
18 | 			</Target>
19 | 			<Target title="Release">
20 | 				<Option output="bin/Release/TupleFunTimes" prefix_auto="1" extension_auto="1" />
21 | 				<Option working_dir="bin/Debug/" />
22 | 				<Option object_output="obj/Release/" />
23 | 				<Option type="1" />
24 | 				<Option compiler="gcc" />
25 | 				<Compiler>
26 | 					<Add option="-O2" />
27 | 				</Compiler>
28 | 				<Linker>
29 | 					<Add option="-s" />
30 | 				</Linker>
31 | 			</Target>
32 | 		</Build>
33 | 		<Compiler>
34 | 			<Add option="-O3" />
35 | 			<Add option="-std=c++11" />
36 | 			<Add option="-Wall" />
37 | 			<Add option="-fexceptions" />
38 | 			<Add directory="include" />
39 | 		</Compiler>
40 | 		<Unit filename="include/Reflectable/for_each.h" />
41 | 		<Unit filename="include/Reflectable/reflectable.h" />
42 | 		<Unit filename="include/Reflectable/tagged_tuple.h" />
43 | 		<Unit filename="main.cpp" />
44 | 		<Extensions>
45 | 			<code_completion />
46 | 			<envvars />
47 | 			<debugger />
48 | 		</Extensions>
49 | 	</Project>
50 | </CodeBlocks_project_file>
51 | 


--------------------------------------------------------------------------------
/include/Reflectable/tagged_tuple.h:
--------------------------------------------------------------------------------
 1 | #ifndef REFLECTABLE_TAGGED_TUPLE_H_INCLUDED
 2 | #define REFLECTABLE_TAGGED_TUPLE_H_INCLUDED
 3 | 
 4 | #include <tuple>
 5 | 
 6 | // ************************************************************************************************
 7 | // Code stolen from: http://stackoverflow.com/a/13066078
 8 | 
 9 | template<typename... Ts> struct typelist {
10 |   template<typename T> using prepend = typelist<T, Ts...>;
11 | };
12 | 
13 | template<typename T, typename... Ts> struct index;
14 | template<typename T, typename... Ts> struct index<T, T, Ts...>:
15 |   std::integral_constant<int, 0> {};
16 | template<typename T, typename U, typename... Ts> struct index<T, U, Ts...>:
17 |   std::integral_constant<int, index<T, Ts...>::value + 1> {};
18 | 
19 | template<int n, typename... Ts> struct nth_impl;
20 | template<typename T, typename... Ts> struct nth_impl<0, T, Ts...> {
21 |   using type = T; };
22 | template<int n, typename T, typename... Ts> struct nth_impl<n, T, Ts...> {
23 |   using type = typename nth_impl<n - 1, Ts...>::type; };
24 | template<int n, typename... Ts> using nth = typename nth_impl<n, Ts...>::type;
25 | 
26 | template<int n, int m, typename... Ts> struct extract_impl;
27 | template<int n, int m, typename T, typename... Ts>
28 | struct extract_impl<n, m, T, Ts...>: extract_impl<n, m - 1, Ts...> {};
29 | template<int n, typename T, typename... Ts>
30 | struct extract_impl<n, 0, T, Ts...> { using types = typename
31 |   extract_impl<n, n - 1, Ts...>::types::template prepend<T>; };
32 | template<int n, int m> struct extract_impl<n, m> {
33 |   using types = typelist<>; };
34 | template<int n, int m, typename... Ts> using extract = typename
35 |   extract_impl<n, m, Ts...>::types;
36 | 
37 | template<typename S, typename T> struct tt_impl;
38 | template<typename... Ss, typename... Ts>
39 | struct tt_impl<typelist<Ss...>, typelist<Ts...>>:
40 |   public std::tuple<Ts...> {
41 |   template<typename... Args> tt_impl(Args &&...args):
42 |     std::tuple<Ts...>(std::forward<Args>(args)...) {}
43 |   template<typename S> nth<index<S, Ss...>::value, Ts...>& get() {
44 |     return std::get<index<S, Ss...>::value>(*this); }
45 | };
46 | template<typename... Ts> struct tagged_tuple:
47 |   tt_impl<extract<2, 0, Ts...>, extract<2, 1, Ts...>> {
48 |   template<typename... Args> tagged_tuple(Args &&...args):
49 |     tt_impl<extract<2, 0, Ts...>, extract<2, 1, Ts...>>(
50 |       std::forward<Args>(args)...) {}
51 | };
52 | 
53 | #endif // REFLECTABLE_TAGGED_TUPLE_H_INCLUDED
54 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <ctime>
  4 | #include <cstdio>
  5 | 
  6 | #include "Reflectable/reflectable.h"
  7 | 
  8 | struct Foo
  9 | {
 10 |     std::string str;
 11 |     int i;
 12 | };
 13 | 
 14 | std::ostream& operator<<(std::ostream& left, const Foo& right)
 15 | {
 16 |     return left << "str: " << right.str << ", " << "i: " << right.i;
 17 | }
 18 | 
 19 | /// \brief A super basic printer
 20 | class SamplePrinter
 21 | {
 22 |     public:
 23 |         /// \brief Int serialization
 24 |         void operator () (int x)
 25 |         {
 26 |             std::cout << "int: " << x << std::endl;
 27 |         }
 28 | 
 29 |         /// \brief Float serialization
 30 |         void operator () (float x)
 31 |         {
 32 |             std::cout << "float: " << x << std::endl;
 33 |         }
 34 | 
 35 |         /// \brief Double serialization
 36 |         void operator () (double x)
 37 |         {
 38 |             std::cout << "double: " << x << std::endl;
 39 |         }
 40 | 
 41 |         /// \brief String serialization
 42 |         void operator () (const std::string& x)
 43 |         {
 44 |             std::cout << "string: " << x << std::endl;
 45 |         }
 46 | 
 47 |         /// \brief The generic case
 48 |         template <typename X>
 49 |         void operator () (const X& x)
 50 |         {
 51 |             std::cout << "other: " << x << std::endl;
 52 |         }
 53 | 
 54 |     private:
 55 | };
 56 | 
 57 | struct Test : public Reflectable<struct name_,      std::string,
 58 |                                  struct health_,    int,
 59 |                                  struct foo_,       Foo>
 60 | {
 61 | };
 62 | 
 63 | struct TestReferences : public Reflectable<struct name_,      std::string,
 64 |                                            struct health_,    int,
 65 |                                            struct foo_,       Foo>
 66 | {
 67 |     TestReferences() : name(get<name_>()), health(get<health_>()), foo(get<foo_>())
 68 |     {
 69 |     }
 70 | 
 71 |     std::string& name;
 72 |     int& health;
 73 |     Foo& foo;
 74 | };
 75 | 
 76 | struct TestNormal
 77 | {
 78 |     std::string name;
 79 |     int health;
 80 |     Foo foo;
 81 | };
 82 | 
 83 | int main()
 84 | {
 85 |     Test test;
 86 |     test.get<name_>() = "bob";
 87 |     test.get<health_>() = 42;
 88 |     test.get<foo_>().str = "hello";
 89 |     test.get<foo_>().i = 24;
 90 | 
 91 |     test.iterate(SamplePrinter());
 92 | 
 93 |     std::cout << "\n\nBenchmarks:\n\n";
 94 | 
 95 |     clock_t time;
 96 | 
 97 |     // ******************************************
 98 |     // Raw for loop
 99 | 
100 |     time = clock();
101 |     for (int i = 0; i < 100000000; i++);
102 |     time = clock()-time;
103 |     std::cout << "Raw for loop: " << static_cast<float>(time)/CLOCKS_PER_SEC << "s\n";
104 | 
105 |     // ******************************************
106 |     // Regular benchmark
107 | 
108 |     TestNormal testNormal;
109 | 
110 |     time = clock();
111 |     for (int i = 0; i < 100000000; i++)
112 |     {
113 |         testNormal.foo.i = i;
114 |     }
115 |     time = clock()-time;
116 |     std::cout << "Regular access: " << static_cast<float>(time)/CLOCKS_PER_SEC << "s\n";
117 | 
118 |     // ******************************************
119 |     // Reflectable benchmark
120 | 
121 |     time = clock();
122 |     for (int i = 0; i < 100000000; i++)
123 |     {
124 |         test.get<foo_>().i = i;
125 |     }
126 |     time = clock()-time;
127 |     std::cout << "Reflectable access: " << static_cast<float>(time)/CLOCKS_PER_SEC << "s\n";
128 | 
129 |     // ******************************************
130 |     // Reflectable with reference benchmark
131 | 
132 |     TestReferences testRef;
133 | 
134 |     time = clock();
135 |     for (int i = 0; i < 100000000; i++)
136 |     {
137 |         testRef.foo.i = i;
138 |     }
139 |     time = clock()-time;
140 |     std::cout << "Reflectable with reference access: " << static_cast<float>(time)/CLOCKS_PER_SEC << "s\n";
141 | 
142 |     return 0;
143 | }
144 | 


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