type_magic/module.cpp at main · braxtoncuneo/type_magic · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <type_traits>
#include <cassert>
#include <stdexcept>
#include <vector>
#include <cxxabi.h>

#include "preamble.h"


#include "sanity_check.cpp"


#include "config.h"


#include "container/mod.h"
#include "context/mod.h"
#include "core/mod.h"


#include "postamble.h"


// Traits
struct isA{};
struct isB{};


template<typename CONTEXT>
struct A {
    int x;
    double &get_y() {
        return via<isB>(this).y;
    }
};

using aModule = context::SimpleModule <
    Meta<A>,
    context::RequirementSet<>,
    context::ImplementationSet<isA>
>;


template<typename CONTEXT>
struct B {
    double y;
    int &get_x() {
        return via<isA>(this).x;
    }
};


using bModule = context::SimpleModule <
    Meta<B>,
    context::RequirementSet<>,
    context::ImplementationSet<isB>
>;

typedef context::ModuleBundle<
    aModule,
    bModule
> rootModule;


struct Bad {};
struct Worse {};


template<typename CTX>
void run() {


    if constexpr (CTX::Info::SATISFIED) {

        CTX ctx(
            As<isA,CTX>{1234},
            As<isB,CTX>{5.67}
        );

        as<isA>(ctx).get_y() *= 2;
        as<isB>(ctx).get_x() *= 4;

        std::cout << as<isA>(ctx).x << std::endl;
        std::cout << as<isB>(ctx).y << std::endl;

    } else {
        CTX ctx;
        std::cout << as<context::ContextInfo>(ctx).error_string();
    }

}

int main() {

    typedef typename context::CreateContextType<
        rootModule,
        container::TypeSet<
            isA,
            isB
         >,
        context::EagerSolve
    >::type Ctx;

    run<Ctx>();

    return 0;
}