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