kDB: Knowledge DataBase
Loading...
Searching...
No Matches
Builders.h
1#pragma once
2
3#include "Nodes.h"
4
5#include <knowRDF/Literal.h>
6
7namespace kDB::SPARQL::Algebra::Builders
8{
9 class TriplesList;
10#define KDB_SPARQL_ALGEBRA_GENERATE(_KLASS_NAME_, _MEMBER_DEF_) \
11 class _KLASS_NAME_;
12 #include "NodesDefs.h"
13
14#undef KDB_SPARQL_ALGEBRA_GENERATE
15
16 namespace details
17 {
18 namespace
19 {
20 template<typename _T_>
21 struct field_traits
22 {
23 using type = _T_;
24 static constexpr bool isBuilder = false;
25 static const _T_& build(const _T_& _t)
26 {
27 return _t;
28 }
29 };
30
31#define KDB_SPARQL_ALGEBRA_GENERATE(_KLASS_NAME_, _MEMBER_DEF_) \
32 template<> \
33 struct field_traits<_KLASS_NAME_> \
34 { \
35 using type = kDB::SPARQL::Algebra::_KLASS_NAME_ ## CSP; \
36 static constexpr bool isBuilder = false; \
37 template<typename _T_, typename... _TOther_> \
38 static type build(const _T_& _t, const _TOther_&... _others) \
39 { \
40 return new kDB::SPARQL::Algebra::_KLASS_NAME_(field_traits<_T_>::build(_t), field_traits<_TOther_...>::build(_others)...); \
41 } \
42 };
43
44 template<>
45 struct field_traits<NodeCSP>
46 {
47 using type = NodeCSP;
48 static constexpr bool isBuilder = false;
49 template<typename _T_>
50 static NodeCSP build(const _T_& _t)
51 {
52 return _t;
53 }
54 };
55 template<>
56 inline NodeCSP field_traits<NodeCSP>::build<knowRDF::Literal>(const knowRDF::Literal& _t)
57 {
58 return new Algebra::Value(_t);
59 }
60
61 template<typename... _T_>
62 struct field_traits<Alternative<_T_...>>
63 {
64 using type = Alternative<typename field_traits<_T_>::type::Type...>;
65 static constexpr bool isBuilder = false;
66 template<typename _TArg_, std::enable_if_t<field_traits<_TArg_>::isBuilder, bool> = true >
67 static type build(const _TArg_& _t)
68 {
69 return _t.toNode();
70 }
71 template<typename _TArg_, std::enable_if_t<std::is_base_of_v<Node, typename _TArg_::Type>, bool> = true >
72 static type build(const _TArg_& _t)
73 {
74 return _t;
75 }
76
77 template<typename _TArg_, std::enable_if_t<not field_traits<_TArg_>::isBuilder and not std::is_base_of_v<Node, typename _TArg_::Type>, bool> = true >
78 static type build(const _TArg_& _t)
79 {
80 static_assert(true, "Alternative can only be set with a builder or one of the alternative value as argument");
81 }
82 };
83 template<typename _T_>
84 struct field_traits<QList<_T_>>
85 {
86 using contained_type = typename field_traits<_T_>::type;
87 using type = QList<contained_type>;
88 static constexpr bool isBuilder = false;
89 template<typename _TArg_, typename... _TOther_>
90 static type build(const _TArg_& _t, const _TOther_&... _others)
91 {
92 type value;
93 build(&value, _t, _others...);
94 return value;
95 }
96 template<typename _TArg_>
97 static type build(const QList<_TArg_>& _t)
98 {
99 type value;
100 for(int i = 0; i < _t.size(); ++i)
101 {
102 value.append(field_traits<contained_type>::build(_t));
103 }
104 return value;
105 }
106 static type build(const QList<_T_>& _t)
107 {
108 return _t;
109 }
110 static type build(const TriplesList& _t);
111 private:
112 static void build(type*)
113 {}
114 template<typename _TArg_, typename... _TOther_>
115 static void build(type* _list, const _TArg_& _t, const _TOther_&... _others) {
116 _list->append(field_traits<contained_type>::build(_t));
117 build(_list, _others...);
118 }
119 };
120
121 #include "NodesDefs.h"
122
123 #undef KDB_SPARQL_ALGEBRA_GENERATE
124 }
125
126
127 template<typename _T_>
128 struct traits
129 {
130 static constexpr bool has_custom_constructor = false;
131 };
132 template<>
133 struct traits<Variable>
134 {
135 static constexpr bool has_custom_constructor = true;
136 };
137 }
138
139
140#define KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER(_KLASS_NAME_, _TYPE_, _NAME_,...) \
141 template<typename... _TOther_> \
142 _KLASS_NAME_& _NAME_(const _TOther_&... _other);
143
144#define KDB_SPARQL_ALGEBRA_GENERATE_MEMBER_UPDATE(_KLASS_NAME_, _TYPE_, _NAME_,...) \
145 void update_ ## _NAME_(const details::field_traits<_TYPE_>::type& _type);
146
147#define KDB_SPARQL_ALGEBRA_GENERATE(_KLASS_NAME_, _MEMBER_DEF_) \
148 class _KLASS_NAME_ \
149 { \
150 public: \
151 _KLASS_NAME_(); \
152 _KLASS_NAME_(const _KLASS_NAME_&) = delete; \
153 _KLASS_NAME_& operator=(const _KLASS_NAME_&) = delete; \
154 template<typename... _TOther_, std::enable_if_t<details::traits<_KLASS_NAME_>::has_custom_constructor and sizeof...(_TOther_) != 0, bool> = true> \
155 _KLASS_NAME_(const _TOther_&... _other); \
156 ~_KLASS_NAME_(); \
157 QPair<QString, knowCore::ValueHash> toQueryString() const; \
158 kDB::SPARQL::Algebra::_KLASS_NAME_ ## CSP toNode() const; \
159 operator kDB::SPARQL::Algebra::_KLASS_NAME_ ## CSP () const { return toNode(); } \
160 operator Node ## CSP () const { return toNode(); } \
161 public: \
162 _MEMBER_DEF_(_KLASS_NAME_, KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER); \
163 public: \
164 _MEMBER_DEF_(_KLASS_NAME_, KDB_SPARQL_ALGEBRA_GENERATE_MEMBER_UPDATE); \
165 private: \
166 struct Private; \
167 Private* const d; \
168 };
169
170#include "NodesDefs.h"
171
172#undef KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER
173#undef KDB_SPARQL_ALGEBRA_GENERATE_MEMBER_UPDATE
174#undef KDB_SPARQL_ALGEBRA_GENERATE
175
179 class TriplesList
180 {
181 public:
182 template<typename _T1_, typename _T2_, typename _T3_>
183 void append(const _T1_& _subject, const _T2_& _predicate, const _T3_& _object)
184 {
185 Triple builder;
186 builder.subject(toNode(_subject));
187 builder.predicate(toNode(_predicate));
188 builder.object(toNode(_object));
189 m_triples.append(builder.toNode());
190 }
191 QList<kDB::SPARQL::Algebra::TripleCSP> toTriples() const { return m_triples; }
192 operator QList<kDB::SPARQL::Algebra::TripleCSP>() const { return toTriples(); }
193 operator QList<kDB::SPARQL::Algebra::NodeCSP>() const;
194 private:
195 NodeCSP toNode(const NodeCSP& _node)
196 {
197 return _node;
198 }
199 NodeCSP toNode(const knowCore::Uri& _node)
200 {
201 return new Algebra::Term(_node);
202 }
203
204 QList<kDB::SPARQL::Algebra::TripleCSP> m_triples;
205 };
206
207 namespace details
208 {
209 void customConstructor(Variable* _var_builder, const QString& _name)
210 {
211 _var_builder->name(_name);
212 }
213 }
214
215#define KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER_DEFINITION(_KLASS_NAME_, _TYPE_, _NAME_,...) \
216 template<typename... _TOther_> \
217 _KLASS_NAME_& _KLASS_NAME_::_NAME_(const _TOther_&... _other) \
218 { \
219 update_ ## _NAME_(details::field_traits<_TYPE_>::build(_other...)); \
220 return *this; \
221 }
222
223#define KDB_SPARQL_ALGEBRA_GENERATE(_KLASS_NAME_, _MEMBER_DEF_) \
224 template<typename... _TOther_, std::enable_if_t<details::traits<_KLASS_NAME_>::has_custom_constructor and sizeof...(_TOther_) != 0, bool>> \
225 _KLASS_NAME_::_KLASS_NAME_(const _TOther_&... _other) : _KLASS_NAME_::_KLASS_NAME_() \
226 { \
227 details::customConstructor(this, _other...); \
228 } \
229 _MEMBER_DEF_(_KLASS_NAME_, KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER_DEFINITION); \
230
231#include "NodesDefs.h"
232#undef KDB_SPARQL_ALGEBRA_GENERATE
233#undef KDB_SPARQL_ALGEBRA_GENERATE_GENERIC_MEMBER_SETTER_DEFINITION
234
235 namespace details
236 {
237 template<typename _T_>
238 typename field_traits<QList<_T_>>::type field_traits<QList<_T_>>::build(const TriplesList& _t)
239 {
240 return _t;
241 }
242 }
243
244}
245
QList
Definition Revision.h:9
knowCore::Uri
Definition Uri.h:15
knowRDF::Literal
Definition Literal.h:14
Generated by doxygen 1.12.0