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
|
from utils import _n, _ext, _n_item, get_namespace
from resource_classes import _resource_classes
_templates = {}
_templates['reply_class'] = \
'''\
namespace reply {
namespace detail {
template<typename Connection,
typename Check,
typename CookieFunction>
class %s
: public xpp::generic::reply<%s<Connection, Check, CookieFunction>,
Connection,
Check,
SIGNATURE(%s_reply),
CookieFunction>
{
public:
typedef xpp::generic::reply<%s<Connection, Check, CookieFunction>,
Connection,
Check,
SIGNATURE(%s_reply),
CookieFunction>
base;
template<typename C, typename ... Parameter>
%s(C && c, Parameter && ... parameter)
: base(std::forward<C>(c), std::forward<Parameter>(parameter) ...)
{}
%s\
%s\
}; // class %s
} // namespace detail
namespace checked {
template<typename Connection>
using %s = detail::%s<
Connection, xpp::generic::checked_tag,
SIGNATURE(%s)>;
} // namespace checked
namespace unchecked {
template<typename Connection>
using %s = detail::%s<
Connection, xpp::generic::unchecked_tag,
SIGNATURE(%s_unchecked)>;
} // namespace unchecked
} // namespace reply
'''
def _reply_class(name, c_name, ns, cookie, accessors):
return _templates['reply_class'] % \
( name
, name # base class
, c_name # %s_reply
, name # typedef
, c_name # %s_reply
, name # c'tor
, cookie.make_static_getter()
, accessors
, name # // class %s
, name # checked { using %s =
, name # checked { detail::%s
, c_name # checked { SIGNATURE
, name # unchecked { using %s =
, name # unchecked { detail::%s
, c_name # unchecked { SIGNATURE
)
_templates['reply_member_accessor'] = \
'''\
template<typename ReturnType = %s, typename ... Parameter>
ReturnType
%s(Parameter && ... parameter)
{
using make = xpp::generic::factory::make<Connection,
decltype(this->get()->%s),
ReturnType,
Parameter ...>;
return make()(this->m_c,
this->get()->%s,
std::forward<Parameter>(parameter) ...);
}
'''
def _reply_member_accessor(request_name, name, c_type, template_type):
return _templates['reply_member_accessor'] % \
( c_type
, name
, name
, name
)
class CppReply(object):
def __init__(self, namespace, name, cookie, reply, accessors, parameter_list):
self.namespace = namespace
self.name = name
self.reply = reply
self.cookie = cookie
self.accessors = accessors
self.parameter_list = parameter_list
self.request_name = _ext(_n_item(self.name[-1]))
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def make_accessors(self):
return "\n".join(["\n%s\n" % a for a in self.accessors])
def make(self):
accessors = [self.make_accessors()]
naccessors = len(self.accessors)
for field in self.reply.fields:
if (field.field_type[-1] in _resource_classes
and not field.type.is_list
and not field.type.is_container):
naccessors = naccessors + 1
name = field.field_name.lower()
c_type = field.c_field_type
template_type = field.field_name.capitalize()
accessors.append(_reply_member_accessor(self.request_name, name, c_type, template_type))
result = ""
result += _reply_class(
self.request_name, self.c_name, get_namespace(self.namespace),
self.cookie, "\n".join(accessors))
return result
|
