boost_describe 0.1.0

Boost C++ library boost_describe packaged using Zanbil
Documentation 
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// Copyright 2020, 2021 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#include <boost/describe/bases.hpp>
#include <boost/describe/members.hpp>
#include <boost/describe/class.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>

template<class A1, class A2> struct X
{
    A1 a1;
    A2 a2;

    BOOST_DESCRIBE_CLASS(X, (), (a1, a2), (), ())
};

template<class B1, class B2> class Y
{
private:

    B1 b1;
    B2 b2;

    BOOST_DESCRIBE_CLASS(Y, (), (), (), (b1, b2))
};

template<class T1, class T2> class Z: public X<T1, T2>
{
private:

    // error: declaration of 'typedef struct X<T1, T2> Z<T1, T2>::X' changes meaning of 'X' (g++)
    // typedef X<T1, T2> X;

    typedef X<T1, T2> XB;

protected:

    Y<T1, T2> y;

    BOOST_DESCRIBE_CLASS(Z, (XB), (), (y), ())
};

#if !defined(BOOST_DESCRIBE_CXX14)

#include <boost/config/pragma_message.hpp>

BOOST_PRAGMA_MESSAGE("Skipping test because C++14 is not available")
int main() {}

#elif defined(BOOST_MSVC) && BOOST_MSVC < 1920

BOOST_PRAGMA_MESSAGE("Skipping test because BOOST_MSVC is below 1920")
int main() {}

#elif defined(BOOST_MSVC) && BOOST_MSVC >= 1920 && BOOST_MSVC < 1940 && _MSVC_LANG <= 201703L

BOOST_PRAGMA_MESSAGE("Skipping test because BOOST_MSVC is 192x or 193x and _MSVC_LANG is 201703L or below")
int main() {}

#else

#include <boost/mp11.hpp>
using namespace boost::mp11;

int main()
{
    using namespace boost::describe;
    using namespace boost::mp11;

    {
        using L = describe_members<X<int, float>, mod_any_access>;

        BOOST_TEST_EQ( mp_size<L>::value, 2 );

        using D1 = mp_at_c<L, 0>;
        using D2 = mp_at_c<L, 1>;

        BOOST_TEST( D1::pointer == (&X<int, float>::a1) );
        BOOST_TEST_CSTR_EQ( D1::name, "a1" );
        BOOST_TEST_EQ( D1::modifiers, mod_public );

        BOOST_TEST( D2::pointer == (&X<int, float>::a2) );
        BOOST_TEST_CSTR_EQ( D2::name, "a2" );
        BOOST_TEST_EQ( D2::modifiers, mod_public );
    }

    {
        using L = describe_members<Y<int, float>, mod_any_access>;

        BOOST_TEST_EQ( mp_size<L>::value, 2 );

        using D1 = mp_at_c<L, 0>;
        using D2 = mp_at_c<L, 1>;

        // BOOST_TEST( D1::pointer == (&Y<int, float>::b1) );
        BOOST_TEST_CSTR_EQ( D1::name, "b1" );
        BOOST_TEST_EQ( D1::modifiers, mod_private );

        // BOOST_TEST( D2::pointer == (&Y<int, float>::b2) );
        BOOST_TEST_CSTR_EQ( D2::name, "b2" );
        BOOST_TEST_EQ( D2::modifiers, mod_private );
    }

    {
        using L = describe_members<Z<int, float>, mod_any_access>;

        BOOST_TEST_EQ( mp_size<L>::value, 1 );

        using D1 = mp_at_c<L, 0>;

        // BOOST_TEST( D1::pointer == (&Z<int, float>::y) );
        BOOST_TEST_CSTR_EQ( D1::name, "y" );
        BOOST_TEST_EQ( D1::modifiers, mod_protected );
    }

    {
        using L = describe_members<Z<int, float>, mod_any_access | mod_inherited>;

        BOOST_TEST_EQ( mp_size<L>::value, 3 );

        using D1 = mp_at_c<L, 0>;
        using D2 = mp_at_c<L, 1>;
        using D3 = mp_at_c<L, 2>;

        BOOST_TEST( D1::pointer == (&X<int, float>::a1) );
        BOOST_TEST_CSTR_EQ( D1::name, "a1" );
        BOOST_TEST_EQ( D1::modifiers, mod_public | mod_inherited );

        BOOST_TEST( D2::pointer == (&X<int, float>::a2) );
        BOOST_TEST_CSTR_EQ( D2::name, "a2" );
        BOOST_TEST_EQ( D2::modifiers, mod_public | mod_inherited );

        // BOOST_TEST( D3::pointer == (&Z<int, float>::y) );
        BOOST_TEST_CSTR_EQ( D3::name, "y" );
        BOOST_TEST_EQ( D3::modifiers, mod_protected );
    }

    return boost::report_errors();
}

#endif // !defined(BOOST_DESCRIBE_CXX14)