knowL: Knowledge Libraries
Loading...
Searching...
No Matches
MetaTypeImplementation.h
1#pragma once
2
3#include <QCborArray>
4#include <QCryptographicHash>
5#include <QJsonArray>
6#include <QJsonDocument>
7#include <QJsonObject>
8
9#include "Value.h"
10
11#include "Uris/askcore_datatype.h"
12
13namespace knowCore
14{
15 class BigNumber;
16
17 // BEGIN Serialisation/Deserialisation Contexts
18
19 namespace details
20 {
21 template<typename _T_, typename _TC_>
22 cres_qresult<_T_*> SeDeContexts_getContext(_TC_* _contexts, const knowCore::Uri& _uri)
23 {
24 cres_try(auto context, _contexts->getContext(_uri));
25 _T_* casted = dynamic_cast<_T_*>(context);
26 if(casted)
27 {
28 return cres_success(casted);
29 }
30 else
31 {
32 return cres_failure("Cannot cast context to '{}'", knowCore::prettyTypename<_T_>());
33 }
34 }
35 } // namespace details
36
37 template<typename _T_>
38 cres_qresult<_T_*> DeserialisationContexts::getContext(const knowCore::Uri& _uri) const
39 {
40 return details::SeDeContexts_getContext<_T_>(this, _uri);
41 }
42
43 template<typename _T_>
44 cres_qresult<_T_*> SerialisationContexts::getContext(const knowCore::Uri& _uri) const
45 {
46 return details::SeDeContexts_getContext<_T_>(this, _uri);
47 }
48
49 // END Serialisation/Deserialisation Contexts
50
51 // BEGIN Converter API
52 class Uri;
53 template<typename _TFrom_, typename _TTo_, TypeCheckingMode _TypeCheckingMode_>
54 struct Converter;
55 template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
56 struct Comparator;
57 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
58 struct ArithmeticOperation;
59
60 template<typename _TFrom_, typename _TTo_>
61 requires(std::is_convertible_v<_TFrom_, _TTo_> and not std::is_arithmetic_v<_TFrom_>)
62 struct Converter<_TFrom_, _TTo_, TypeCheckingMode::Safe>
63 {
64 static inline cres_qresult<void> convert(const _TFrom_* _from, _TTo_* _to)
65 {
66 *_to = *_from;
67 return cres_success();
68 }
69 };
70 template<typename _TFrom_, typename _TTo_,
71 TypeCheckingMode _TypeCheckingMode_ = TypeCheckingMode::Safe>
72 inline cres_qresult<void> convert(const _TFrom_* _from, _TTo_* _to)
73 {
74 return Converter<_TFrom_, _TTo_, _TypeCheckingMode_>::convert(_from, _to);
75 }
76
77 template<ComparisonOperator _operator_, typename _TFrom_, typename _TTo_>
78 inline cres_qresult<bool> compare(const _TFrom_& _from, _TTo_& _to)
79 {
80 return Comparator<_operator_, _TFrom_, _TTo_>::compare(_from, _to);
81 }
82 // BEGIN Comparator
83 namespace details
84 {
85 template<typename _TLeft_, typename _TRight_>
86 concept EqualComparable = requires(_TLeft_ a, _TRight_ b) {
87 { a == b } -> std::convertible_to<bool>;
88 };
89 template<typename _TLeft_, typename _TRight_>
90 concept InferiorComparable = requires(_TLeft_ a, _TRight_ b) {
91 { a < b } -> std::convertible_to<bool>;
92 };
93 template<typename _TLeft_, typename _TRight_>
94 concept EqualComparableRV = requires(_TLeft_ a, _TRight_ b) {
95 { a == b } -> std::convertible_to<cres_qresult<bool>>;
96 };
97 template<typename _TLeft_, typename _TRight_>
98 concept InferiorComparableRV = requires(_TLeft_ a, _TRight_ b) {
99 { a < b } -> std::convertible_to<cres_qresult<bool>>;
100 };
101 template<typename _Tp>
102 concept is_integral = std::is_integral_v<_Tp>;
103
104 template<typename _TLeft_, typename _TRight_>
105 concept left_unsigned_right_signed
106 = std::unsigned_integral<_TLeft_> and std::signed_integral<_TRight_>
107 and std::integral<_TRight_>;
108 template<typename _TLeft_, typename _TRight_>
109 concept left_signed_right_unsigned
110 = std::signed_integral<_TLeft_> and std::unsigned_integral<_TRight_>
111 and std::integral<_TLeft_>;
112 } // namespace details
113
114 template<typename _TLeft_, typename _TRight_>
115 requires details::InferiorComparable<_TLeft_, _TRight_>
116 and (not details::left_unsigned_right_signed<_TLeft_, _TRight_>)
117 and (not details::left_signed_right_unsigned<_TLeft_, _TRight_>)
118 struct Comparator<ComparisonOperator::Inferior, _TLeft_, _TRight_>
119 {
120 static cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right)
121 {
122 return cres_success(_left < _right);
123 }
124 };
125 template<typename _TLeft_, typename _TRight_>
126 requires details::EqualComparable<_TLeft_, _TRight_>
127 and (not details::left_unsigned_right_signed<_TLeft_, _TRight_>)
128 and (not details::left_signed_right_unsigned<_TLeft_, _TRight_>)
129 struct Comparator<ComparisonOperator::Equal, _TLeft_, _TRight_>
130 {
131 static inline cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right)
132 {
133 return cres_success(_left == _right);
134 }
135 };
136
137 template<typename _TLeft_, typename _TRight_>
138 requires details::InferiorComparableRV<_TLeft_, _TRight_>
139 struct Comparator<ComparisonOperator::Inferior, _TLeft_, _TRight_>
140 {
141 static cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right)
142 {
143 return _left < _right;
144 }
145 };
146 template<typename _TLeft_, typename _TRight_>
147 requires details::EqualComparableRV<_TLeft_, _TRight_>
148 struct Comparator<ComparisonOperator::Equal, _TLeft_, _TRight_>
149 {
150 static inline cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right)
151 {
152 return _left == _right;
153 }
154 };
155 // END Comparator
156
157 // BEGIN ArithmeticOperation
158 namespace details
159 {
160 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
161 struct op_trait;
162
163 template<typename _TLeft_, typename _TRight_>
164 struct op_trait<ArithmeticOperator::Addition, _TLeft_, _TRight_>
165 {
166 static auto compute(_TLeft_ _x, _TRight_ _y) { return _x + _y; }
167 };
168 template<typename _TLeft_, typename _TRight_>
169 struct op_trait<ArithmeticOperator::Substraction, _TLeft_, _TRight_>
170 {
171 static auto compute(_TLeft_ _x, _TRight_ _y) { return _x - _y; }
172 };
173 template<typename _TLeft_, typename _TRight_>
174 struct op_trait<ArithmeticOperator::Division, _TLeft_, _TRight_>
175 {
176 static auto compute(_TLeft_ _x, _TRight_ _y) { return _x / _y; }
177 };
178 template<typename _TLeft_, typename _TRight_>
179 struct op_trait<ArithmeticOperator::Multiplication, _TLeft_, _TRight_>
180 {
181 static auto compute(_TLeft_ _x, _TRight_ _y) { return _x * _y; }
182 };
183
184 template<typename T>
185 concept arithmetic = std::is_arithmetic_v<T>;
186 } // namespace details
187 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
188 requires details::arithmetic<_TLeft_> and details::arithmetic<_TRight_>
189 struct ArithmeticOperation<_operator_, _TLeft_, _TRight_>
190 {
191 using op_trait = details::op_trait<_operator_, _TLeft_, _TRight_>;
192 static cres_qresult<knowCore::Value> compute(const _TLeft_& _left, const _TRight_& _right)
193 {
194 return cres_success(Value::fromValue(op_trait::compute(_left, _right)));
195 }
196 };
197
198 // END ArithmeticOperation
199
200 namespace details
201 {
202 class MoreDetails
203 {
204 template<typename _TTo_>
205 friend struct ToValueListConversionImplementation;
206 template<typename _TTo_>
207 friend struct FromValueListConversionImplementation;
208 static QList<knowCore::Value> values(const void* _from);
209 static void assign(const QList<knowCore::Value>& _list, void* _to);
210 };
211 template<typename _TFrom_, typename _TTo_>
212 struct TypeConversionImplementation : public AbstractTypeConversion
213 {
214 knowCore::Uri from() const override { return MetaTypeInformation<_TFrom_>::uri(); }
215 knowCore::Uri to() const override { return MetaTypeInformation<_TTo_>::uri(); }
216 cres_qresult<void> convert(const void* _from, void* _to) const override
217 {
218 return convert(reinterpret_cast<const _TFrom_*>(_from), reinterpret_cast<_TTo_*>(_to));
219 }
220 virtual cres_qresult<void> convert(const _TFrom_* _from, _TTo_* _to) const = 0;
221 };
227 template<typename _TTo_>
228 struct FromValueListConversionImplementation : public AbstractTypeConversion
229 {
230 knowCore::Uri from() const override { return Uris::askcore_datatype::valuelist; }
231 knowCore::Uri to() const override { return MetaTypeInformation<_TTo_>::uri(); }
232 cres_qresult<void> convert(const void* _from, void* _to) const override
233 {
234 return convert(MoreDetails::values(_from), reinterpret_cast<_TTo_*>(_to));
235 }
236 virtual cres_qresult<void> convert(const QList<knowCore::Value>& _from, _TTo_* _to) const
237 {
238 clog_debug_vn(_from, _from.size());
239 QList<typename _TTo_::Type> l;
240 for(const knowCore::Value& val : _from)
241 {
242 cres_try(typename _TTo_::Type t, val.value<typename _TTo_::Type>());
243 l.append(t);
244 }
245 *_to = l;
246 clog_debug_vn(_to->size());
247 return cres_success();
248 }
249 };
250 template<typename _TFrom_>
251 struct ToValueListConversionImplementation : public AbstractTypeConversion
252 {
253 knowCore::Uri from() const override { return MetaTypeInformation<_TFrom_>::uri(); }
254 knowCore::Uri to() const override { return Uris::askcore_datatype::valuelist; }
255 cres_qresult<void> convert(const void* _from, void* _to) const override
256 {
257 MoreDetails::assign(convert(reinterpret_cast<const _TFrom_*>(_from)), _to);
258 return cres_success();
259 }
260 virtual QList<knowCore::Value> convert(const _TFrom_* _from) const
261 {
262 clog_debug_vn(_from->size());
263 QList<knowCore::Value> l;
264 for(const typename _TFrom_::Type& val : *_from)
265 {
266 l.append(Value::fromValue(val));
267 }
268 return l;
269 }
270 };
271
272 template<typename _TFrom_, typename _TTo_, TypeCheckingMode _TypeCheckingMode_>
273 struct ConvertConversionImplementation : public TypeConversionImplementation<_TFrom_, _TTo_>
274 {
275 cres_qresult<void> convert(const _TFrom_* _from, _TTo_* _to) const override
276 {
277 return Converter<_TFrom_, _TTo_, _TypeCheckingMode_>::convert(_from, _to);
278 }
279 };
280 template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
281 struct TypeComparatorImplementation : public AbstractTypeComparator
282 {
283 ComparisonOperator comparisonOperator() const override { return _operator_; }
284 knowCore::Uri left() const override { return MetaTypeInformation<_TLeft_>::uri(); }
285 knowCore::Uri right() const override { return MetaTypeInformation<_TRight_>::uri(); }
286 cres_qresult<bool> compare(const void* _left, const void* _right) const override
287 {
288 return compare(*reinterpret_cast<const _TLeft_*>(_left),
289 *reinterpret_cast<const _TRight_*>(_right));
290 }
291 virtual cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right) const = 0;
292 };
293
294 template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
295 struct ComparatorComparatorImplementation
296 : public TypeComparatorImplementation<_operator_, _TLeft_, _TRight_>
297 {
298 cres_qresult<bool> compare(const _TLeft_& _left, const _TRight_& _right) const override
299 {
300 return Comparator<_operator_, _TLeft_, _TRight_>::compare(_left, _right);
301 }
302 };
303 /*************************
304 * Artithmetic Operators *
305 *************************/
306 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
307 struct ArtithmeticOperatorImplementation : public AbstractArithmeticOperator
308 {
309 ArithmeticOperator arithmeticOperator() const override { return _operator_; }
310 knowCore::Uri left() const override { return MetaTypeInformation<_TLeft_>::uri(); }
311 knowCore::Uri right() const override { return MetaTypeInformation<_TRight_>::uri(); }
312 cres_qresult<Value> compute(const void* _left, const void* _right) const override
313 {
314 return compute(*reinterpret_cast<const _TLeft_*>(_left),
315 *reinterpret_cast<const _TRight_*>(_right));
316 }
317 virtual cres_qresult<Value> compute(const _TLeft_& _left, const _TRight_& _right) const = 0;
318 };
319
320 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
321 struct ArithmeticOperationArtithmeticOperatorImplementation
322 : public ArtithmeticOperatorImplementation<_operator_, _TLeft_, _TRight_>
323 {
324 cres_qresult<Value> compute(const _TLeft_& _left, const _TRight_& _right) const override
325 {
326 return ArithmeticOperation<_operator_, _TLeft_, _TRight_>::compute(_left, _right);
327 }
328 };
329 } // namespace details
330
344#define KNOWCORE_DEFINE_GENERIC_CONVERT(_TFrom_, _From_Arg_, _TTo_, _To_Arg_, _TypeCheckingMode_) \
345 template<> \
346 struct knowCore::Converter<_TFrom_, _TTo_, knowCore::TypeCheckingMode::_TypeCheckingMode_> \
347 { \
348 static inline cres_qresult<void> convert(const _TFrom_* _From_Arg_, _TTo_* _To_Arg_); \
349 }; \
350 inline cres_qresult<void> \
351 knowCore::Converter<_TFrom_, _TTo_, knowCore::TypeCheckingMode::_TypeCheckingMode_>::convert( \
352 const _TFrom_* _from, _TTo_* _to)
353
367#define KNOWCORE_DEFINE_CONVERT(_TFrom_, _From_Arg_, _TTo_, _To_Arg_, _TypeCheckingMode_) \
368 template<> \
369 struct knowCore::Converter<_TFrom_, _TTo_, knowCore::TypeCheckingMode::_TypeCheckingMode_> \
370 { \
371 static inline cres_qresult<void> convert(const _TFrom_* _From_Arg_, _TTo_* _To_Arg_); \
372 }; \
373 inline cres_qresult<void> \
374 knowCore::Converter<_TFrom_, _TTo_, knowCore::TypeCheckingMode::_TypeCheckingMode_>::convert( \
375 const _TFrom_* _from, _TTo_* _to)
376 // END Converter API
377
378 // BEGIN Variant Marshal API
379 class AbstractToVariantMarshal
380 {
381 public:
382 virtual QVariant toQVariant(const void* _data) = 0;
383 };
384
385 namespace details
386 {
387 template<typename A>
388 concept HasToVariant = requires(A a) {
389 { QVariant(a.toVariant()) };
390 };
391
392 template<typename _T_>
393 class ToVariantMarshalImplementation : public AbstractToVariantMarshal
394 {
395 public:
396 QVariant toQVariant(const void* _data) override
397 {
398 return reinterpret_cast<const _T_*>(_data)->toVariant();
399 }
400 };
401 } // namespace details
402
403 // BEGIN register functions
404 template<typename _T_>
405 void registerMetaType()
406 {
407 MetaTypeRegistry::registerType(MetaTypeInformation<_T_>::definition());
408 if constexpr(details::HasToVariant<_T_>)
409 {
410 MetaTypeRegistry::registerToVariant(MetaTypeInformation<_T_>::uri(),
411 new details::ToVariantMarshalImplementation<_T_>());
412 }
413 }
414
415 template<typename _TFrom_, typename _TTo_>
416 void
417 registerConverter(TypeCheckingMode _mode,
418 const std::function<cres_qresult<void>(const _TFrom_*, _TTo_*)>& _converter)
419 {
420 struct ConversionImplementation : public details::TypeConversionImplementation<_TFrom_, _TTo_>
421 {
422 ConversionImplementation(
423 const std::function<cres_qresult<void>(const _TFrom_*, _TTo_*)>& _converter)
424 : m_converter(_converter)
425 {
426 }
427 cres_qresult<void> convert(const _TFrom_* _from, const _TTo_* _to) const override
428 {
429 return m_converter(_from, _to);
430 }
431 std::function<cres_qresult<void>(const _TFrom_*, _TTo_*)> m_converter;
432 };
433 MetaTypeRegistry::registerConverter(new ConversionImplementation(_converter));
434 }
435
436 namespace details
437 {
438
439 template<typename _TFrom_, typename _TTo_, TypeCheckingMode _TypeCheckingMode_>
440 concept HasConversionMode = requires(_TFrom_* a, _TTo_* b) {
441 { Converter<_TFrom_, _TTo_, _TypeCheckingMode_>::convert(a, b) };
442 };
443
444 } // namespace details
445
446 template<typename _TFrom_, typename _TTo_>
447 void registerConverter()
448 {
449 constexpr bool has_safe = details::HasConversionMode<_TFrom_, _TTo_, TypeCheckingMode::Safe>;
450 constexpr bool has_force = details::HasConversionMode<_TFrom_, _TTo_, TypeCheckingMode::Force>;
451 static_assert(has_safe or has_force, "No converter was defined.");
452 if constexpr(has_safe)
453 {
454 MetaTypeRegistry::registerConverter(
455 TypeCheckingMode::Safe,
456 new details::ConvertConversionImplementation<_TFrom_, _TTo_, TypeCheckingMode::Safe>());
457 }
458 else if constexpr(has_force)
459 {
460 MetaTypeRegistry::registerConverter(
461 TypeCheckingMode::Force,
462 new details::ConvertConversionImplementation<_TFrom_, _TTo_, TypeCheckingMode::Force>());
463 }
464 }
465 template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
466 void registerComparator(
467 const std::function<cres_qresult<bool>(const _TLeft_&, const _TRight_&)>& _comparator)
468 {
469 struct ComparatorImplementation
470 : public details::TypeComparatorImplementation<_operator_, _TLeft_, _TRight_>
471 {
472 ComparatorImplementation(
473 const std::function<cres_qresult<bool>(const _TLeft_&, _TRight_&)>& _comparator)
474 : m_comparator(_comparator)
475 {
476 }
477 cres_qresult<bool> compare(const _TLeft_& _from, const _TRight_& _to) const override
478 {
479 return m_comparator(_from, _to);
480 }
481 std::function<cres_qresult<bool>(const _TLeft_&, const _TRight_&)> m_comparator;
482 };
483 MetaTypeRegistry::registerComparator(new ComparatorImplementation(_comparator));
484 }
485
486 template<ComparisonOperator _operator_, typename _TLeft_, typename _TRight_>
487 void registerComparator()
488 {
489 MetaTypeRegistry::registerComparator(
490 new details::ComparatorComparatorImplementation<_operator_, _TLeft_, _TRight_>());
491 }
492 template<typename _TLeft_, typename _TRight_>
493 void registerComparators()
494 {
495 }
496
497 template<typename _TLeft_, typename _TRight_, ComparisonOperator _comparator_,
498 ComparisonOperator... _comparator_others_>
499 void registerComparators()
500 {
501 registerComparator<_comparator_, _TLeft_, _TRight_>();
502 registerComparators<_TLeft_, _TRight_, _comparator_others_...>();
503 }
504
505 template<ArithmeticOperator _operator_, typename _TLeft_, typename _TRight_>
506 void registerArithmeticOperator()
507 {
508 MetaTypeRegistry::registerArithmeticOperator(
509 new details::ArithmeticOperationArtithmeticOperatorImplementation<_operator_, _TLeft_,
510 _TRight_>());
511 }
512
513 template<typename _TLeft_, typename _TRight_>
514 void registerArithmeticOperators()
515 {
516 }
517
518 template<typename _TLeft_, typename _TRight_, ArithmeticOperator _operator_,
519 ArithmeticOperator... _operator_others_>
520 void registerArithmeticOperators()
521 {
522 registerArithmeticOperator<_operator_, _TLeft_, _TRight_>();
523 registerArithmeticOperators<_TLeft_, _TRight_, _operator_others_...>();
524 }
525
526 template<typename _T_>
527 void registerNumericType()
528 {
529 MetaTypeRegistry::registerNumericType(MetaTypeInformation<_T_>::uri());
530 if constexpr(not std::is_same_v<_T_, BigNumber>)
531 {
532 registerConverter<_T_, BigNumber>();
533 registerConverter<BigNumber, _T_>();
534 }
535 }
536
537 // END register functions
538
539 // BEGIN MetaTypeDefinitionImplementation
540 template<typename _T_>
541 class MetaTypeDefinitionImplementation : public AbstractMetaTypeDefinition
542 {
543 public:
544 MetaTypeDefinitionImplementation() {}
545 private:
546 template<typename _Q_ = MetaTypeInformation<_T_>>
547 requires(details::is_complete_v<_Q_>)
548 knowCore::Uri get_uri() const
549 {
550 return MetaTypeInformation<_T_>::uri();
551 }
552 template<typename _Q_ = MetaTypeInformation<_T_>>
553 requires(not details::is_complete_v<_Q_>)
554 knowCore::Uri get_uri() const
555 {
556 clog_fatal("No metatype information!");
557 }
558 template<typename _Q_ = MetaTypeInformation<_T_>>
559 requires(details::is_complete_v<_Q_>)
560 int get_qMetaTypeId() const
561 {
562 return MetaTypeInformation<_T_>::id();
563 }
564 template<typename _Q_ = MetaTypeInformation<_T_>>
565 requires(not details::is_complete_v<_Q_>)
566 int get_qMetaTypeId() const
567 {
568 clog_fatal("No metatype information!");
569 }
570 protected:
571 knowCore::Uri uri() const override { return get_uri(); }
572 int qMetaTypeId() const override { return get_qMetaTypeId(); }
573 virtual cres_qresult<QByteArray> md5(const _T_& _value) const = 0;
574 virtual cres_qresult<QJsonValue> toJsonValue(const _T_& _value,
575 const SerialisationContexts& _contexts) const
576 = 0;
577 virtual cres_qresult<void>
578 fromJsonValue(_T_* _value, const QJsonValue& _json_value,
579 const knowCore::DeserialisationContexts& _contexts) const
580 = 0;
581 virtual cres_qresult<QCborValue> toCborValue(const _T_& _value,
582 const SerialisationContexts& _contexts) const
583 = 0;
584 virtual cres_qresult<void>
585 fromCborValue(_T_* _value, const QCborValue& _cbor_value,
586 const knowCore::DeserialisationContexts& _contexts) const
587 = 0;
588 virtual cres_qresult<QString> printable(const _T_& _value) const = 0;
589 virtual cres_qresult<QString> toRdfLiteral(const _T_& _value,
590 const SerialisationContexts& _contexts) const
591 = 0;
592 virtual cres_qresult<void> fromRdfLiteral(_T_* _value, const QString& _serialised,
593 const DeserialisationContexts& _contexts) const
594 = 0;
595 protected:
596 cres_qresult<QString> toJsonString(const _T_& _value,
597 const SerialisationContexts& _contexts) const
598 {
599 QJsonDocument doc;
600 cres_try(QJsonValue value, toJsonValue(_value, _contexts));
601 if(value.isArray())
602 {
603 doc.setArray(value.toArray());
604 }
605 else if(value.isObject())
606 {
607 doc.setObject(value.toObject());
608 }
609 else
610 {
611 clog_fatal("toJsonString/fromJsonString only works on object or array");
612 return expectedError("object or array", doc);
613 }
614 return cres_success(QString::fromUtf8(doc.toJson(QJsonDocument::Compact)));
615 }
616 cres_qresult<void> fromJsonString(_T_* _value, const QString& _json_value,
617 const DeserialisationContexts& _contexts) const
618 {
619 QJsonParseError error;
620 QJsonDocument doc = QJsonDocument::fromJson(_json_value.toUtf8(), &error);
621 if(doc.isNull())
622 {
623 return cres_failure(error.errorString());
624 }
625 else
626 {
627 if(doc.isArray())
628 {
629 return fromJsonValue(_value, doc.array(), _contexts);
630 }
631 else if(doc.isObject())
632 {
633 return fromJsonValue(_value, doc.object(), _contexts);
634 }
635 else
636 {
637 return expectedError("object or array", doc);
638 }
639 }
640 }
641 protected:
642 void* allocate() const override { return new _T_; }
643 void* duplicate(const void* _value) const override
644 {
645 return new _T_(*reinterpret_cast<const _T_*>(_value));
646 }
647 void release(void* _value) const override { delete(reinterpret_cast<_T_*>(_value)); }
648 bool compareEquals(const void* _lhs, const void* _rhs) const override
649 {
650 return *reinterpret_cast<const _T_*>(_lhs) == *reinterpret_cast<const _T_*>(_rhs);
651 }
652 cres_qresult<QByteArray> md5(const void* _value) const override
653 {
654 return md5(*reinterpret_cast<const _T_*>(_value));
655 }
656 cres_qresult<QJsonValue> toJsonValue(const void* _value,
657 const SerialisationContexts& _contexts) const override
658 {
659 return toJsonValue(*reinterpret_cast<const _T_*>(_value), _contexts);
660 }
661 cres_qresult<void> fromJsonValue(void* _value, const QJsonValue& _json_value,
662 const DeserialisationContexts& _contexts) const override
663 {
664 return fromJsonValue(reinterpret_cast<_T_*>(_value), _json_value, _contexts);
665 }
666 cres_qresult<QCborValue> toCborValue(const void* _value,
667 const SerialisationContexts& _contexts) const override
668 {
669 return toCborValue(*reinterpret_cast<const _T_*>(_value), _contexts);
670 }
671 cres_qresult<void> fromCborValue(void* _value, const QCborValue& _cbor_value,
672 const DeserialisationContexts& _contexts) const override
673 {
674 return fromCborValue(reinterpret_cast<_T_*>(_value), _cbor_value, _contexts);
675 }
676 cres_qresult<QString> printable(const void* _value) const override
677 {
678 return printable(*reinterpret_cast<const _T_*>(_value));
679 }
680 cres_qresult<QString> toRdfLiteral(const void* _value,
681 const SerialisationContexts& _contexts) const override
682 {
683 return toRdfLiteral(*reinterpret_cast<const _T_*>(_value), _contexts);
684 }
685 cres_qresult<void> fromRdfLiteral(void* _value, const QString& _serialised,
686 const DeserialisationContexts& _contexts) const override
687 {
688 return fromRdfLiteral(reinterpret_cast<_T_*>(_value), _serialised, _contexts);
689 }
690 protected:
691 template<typename _TCoJ_>
692 cres_qerror expectedError(const char* _what, const _TCoJ_& _got) const
693 {
694 return cres_failure("Expected '{}' got '{}'", _what, _got);
695 }
696 template<typename _TCoJ_>
697 cres_qerror expectedArrayError(const _TCoJ_& _coj) const
698 {
699 return expectedError("array", _coj);
700 }
701 template<typename _TCoJ_>
702 cres_qerror expectedObjectError(const _TCoJ_& _coj) const
703 {
704 return expectedError("object", _coj);
705 }
706 };
707 // END MetaTypeDefinitionImplementation
708
709 // BEGIN MetaTypeDefinition for QList
710 template<typename _T_>
711 class MetaTypeDefinition<QList<_T_>> : public MetaTypeDefinitionImplementation<QList<_T_>>
712 {
713 using knowCore::MetaTypeDefinitionImplementation<QList<_T_>>::expectedArrayError;
714 using knowCore::MetaTypeDefinitionImplementation<QList<_T_>>::toJsonString;
715 using knowCore::MetaTypeDefinitionImplementation<QList<_T_>>::fromJsonString;
716 protected:
717 cres_qresult<QByteArray> md5(const QList<_T_>& _value) const override
718 {
719 QCryptographicHash hash(QCryptographicHash::Md5);
720 for(const _T_& v : _value)
721 {
722 cres_try(QByteArray value, m_nested.md5(v));
723 hash.addData(value);
724 }
725 return cres_success(hash.result());
726 }
727 cres_qresult<QJsonValue> toJsonValue(const QList<_T_>& _value,
728 const SerialisationContexts& _contexts) const override
729 {
730 QJsonArray array;
731 for(const _T_& v : _value)
732 {
733 cres_try(QJsonValue value, m_nested.toJsonValue(v, _contexts));
734 array.append(value);
735 }
736 return cres_success(array);
737 }
738 cres_qresult<void>
739 fromJsonValue(QList<_T_>* _value, const QJsonValue& _json_value,
740 const knowCore::DeserialisationContexts& _contexts) const override
741 {
742 if(_json_value.isArray())
743 {
744 deleteAll(*_value);
745 _value->clear();
746 for(const QJsonValue& value : _json_value.toArray())
747 {
748 _T_ v{};
749 cres_try(cres_ignore, m_nested.fromJsonValue(&v, value, _contexts));
750 _value->append(v);
751 }
752 return cres_success();
753 }
754 else
755 {
756 return expectedArrayError(_json_value);
757 }
758 }
759 cres_qresult<QCborValue> toCborValue(const QList<_T_>& _value,
760 const SerialisationContexts& _contexts) const override
761 {
762 QCborArray array;
763 for(const _T_& v : _value)
764 {
765 cres_try(QCborValue value, m_nested.toCborValue(v, _contexts));
766 array.append(value);
767 }
768 return cres_success(array);
769 }
770 cres_qresult<void>
771 fromCborValue(QList<_T_>* _value, const QCborValue& _cbor_value,
772 const knowCore::DeserialisationContexts& _contexts) const override
773 {
774 if(_cbor_value.isArray())
775 {
776 deleteAll(*_value);
777 _value->clear();
778 for(const QCborValue& value : _cbor_value.toArray())
779 {
780 _T_ v{};
781 cres_try(cres_ignore, m_nested.fromCborValue(&v, value, _contexts));
782 _value->append(v);
783 }
784 return cres_success();
785 }
786 else
787 {
788 return expectedArrayError(_cbor_value);
789 }
790 }
791 cres_qresult<QString> printable(const QList<_T_>& _value) const override
792 {
793 QStringList strings;
794 for(const _T_& v : _value)
795 {
796 cres_try(QString value, m_nested.printable(v));
797 strings.append(value);
798 }
799 return cres_success(clog_qt::qformat("[{}]", strings));
800 }
801 cres_qresult<QString> toRdfLiteral(const QList<_T_>& _value,
802 const SerialisationContexts& _contexts) const override
803 {
804 return toJsonString(_value, _contexts);
805 }
806 cres_qresult<void> fromRdfLiteral(QList<_T_>* _value, const QString& _serialised,
807 const DeserialisationContexts& _contexts) const override
808 {
809 return fromJsonString(_value, _serialised, _contexts);
810 }
811 private:
812 MetaTypeDefinition<_T_> m_nested;
813 };
814 // END MetaTypeDefinition for QList
815
816 namespace Details
817 {
818 template<typename _TFrom_, typename _TTo_>
819 inline _TTo_ qt_convert(const _TFrom_& _from)
820 {
821 _TTo_ to;
822 convert(&_from, &to).expect_success();
823 return to;
824 }
825 inline constexpr bool valid(const char* _t) { return _t; }
826 inline constexpr bool valid(const knowCore::Uri&) { return true; }
827 template<typename _T_, typename _T2_, bool _has_converter_>
828 class RegisterConverter;
829 template<typename _T_, typename _T2_>
830 struct RegisterConverter<_T_, _T2_, true>
831 {
832 static void registerConverter()
833 {
834 QMetaType::registerConverter<_T_, _T2_>(qt_convert<_T_, _T2_>);
835 knowCore::registerConverter<_T_, _T2_>();
836 }
837 };
838 template<typename _T_, typename _T2_>
839 struct RegisterConverter<_T_, _T2_, false>
840 {
841 static void registerConverter() {}
842 };
843 template<typename _T_, bool _has_converter_>
844 struct RegisterFromListConverter;
845 template<typename _T_>
846 struct RegisterFromListConverter<_T_, true>
847 {
848 static void registerConverter()
849 {
850 MetaTypeRegistry::registerConverter(
851 TypeCheckingMode::Safe, new details::FromValueListConversionImplementation<_T_>());
852 }
853 };
854 template<typename _T_>
855 struct RegisterFromListConverter<_T_, false>
856 {
857 static void registerConverter() {}
858 };
859 template<typename _T_, bool _has_converter_>
860 struct RegisterToListConverter;
861 template<typename _T_>
862 struct RegisterToListConverter<_T_, true>
863 {
864 static void registerConverter()
865 {
866 MetaTypeRegistry::registerConverter(
867 TypeCheckingMode::Safe, new details::ToValueListConversionImplementation<_T_>());
868 }
869 };
870 template<typename _T_>
871 struct RegisterToListConverter<_T_, false>
872 {
873 static void registerConverter() {}
874 };
875
876 template<typename _T_, bool _is_numeric>
877 struct RegisterNumericDataType;
878 template<typename _T_>
879 struct RegisterNumericDataType<_T_, true>
880 {
881 static void registerNumericDataType() { registerNumericType<_T_>(); }
882 };
883 template<typename _T_>
884 struct RegisterNumericDataType<_T_, false>
885 {
886 static void registerNumericDataType() {}
887 };
888 inline knowCore::Uri makeUri(std::nullptr_t) { clog_fatal("no uri defined for type!"); }
889 template<typename _T_>
890 knowCore::Uri makeUri(const _T_& _uri)
891 {
892 return knowCore::Uri(_uri);
893 }
894 } // namespace Details
895} // namespace knowCore
896
897#define __KNOWCORE_DEFINE_METATYPE__INTERNAL__(_TYPE_, _URI_, _TRAITS_) \
898 knowCore::MetaTypeInformation<_TYPE_> knowCore::MetaTypeInformation<_TYPE_>::s_instance; \
899 knowCore::MetaTypeInformation<_TYPE_>::MetaTypeInformation() \
900 { \
901 m_id = qRegisterMetaType<_TYPE_>(#_TYPE_); \
902 knowCore::Details::RegisterFromListConverter< \
903 _TYPE_, bool((_TRAITS_) & knowCore::MetaTypeTraits::FromValueList)>::registerConverter(); \
904 knowCore::Details::RegisterToListConverter< \
905 _TYPE_, bool((_TRAITS_) & knowCore::MetaTypeTraits::ToValueList)>::registerConverter(); \
906 knowCore::Details::RegisterConverter< \
907 _TYPE_, QString, \
908 bool((_TRAITS_) & knowCore::MetaTypeTraits::ToString)>::registerConverter(); \
909 knowCore::Details::RegisterConverter< \
910 QString, _TYPE_, \
911 bool((_TRAITS_) & knowCore::MetaTypeTraits::FromString)>::registerConverter(); \
912 knowCore::Details::RegisterConverter< \
913 _TYPE_, QByteArray, \
914 bool((_TRAITS_) & knowCore::MetaTypeTraits::ToByteArray)>::registerConverter(); \
915 knowCore::Details::RegisterConverter< \
916 QByteArray, _TYPE_, \
917 bool((_TRAITS_) & knowCore::MetaTypeTraits::FromByteArray)>::registerConverter(); \
918 knowCore::Details::RegisterNumericDataType< \
919 _TYPE_, \
920 bool((_TRAITS_) & knowCore::MetaTypeTraits::NumericType)>::registerNumericDataType(); \
921 init_knowCoreMetaType(); \
922 }
923
924#define KNOWCORE_DEFINE_QT_METATYPE(_TYPE_, _TRAITS_) \
925 void knowCore::MetaTypeInformation<_TYPE_>::init_knowCoreMetaType() {} \
926 __KNOWCORE_DEFINE_METATYPE__INTERNAL__(_TYPE_, nullptr, _TRAITS_)
927
931#define KNOWCORE_DEFINE_METATYPE_URI(_TYPE_, _URI_) \
932 knowCore::Uri knowCore::MetaTypeInformation<_TYPE_>::uri() \
933 { \
934 return knowCore::Details::makeUri(_URI_); \
935 }
936
943#define KNOWCORE_DEFINE_METATYPE(_TYPE_, _URI_, _TRAITS_) \
944 KNOWCORE_DEFINE_METATYPE_URI(_TYPE_, _URI_) \
945 knowCore::AbstractMetaTypeDefinition* knowCore::MetaTypeInformation<_TYPE_>::definition() \
946 { \
947 static knowCore::AbstractMetaTypeDefinition* definition \
948 = new knowCore::MetaTypeDefinition<_TYPE_>(); \
949 return definition; \
950 } \
951 void knowCore::MetaTypeInformation<_TYPE_>::init_knowCoreMetaType() \
952 { \
953 registerMetaType<_TYPE_>(); \
954 } \
955 __KNOWCORE_DEFINE_METATYPE__INTERNAL__(_TYPE_, _URI_, _TRAITS_)
956
957#define __KNOWCORE_REGISTER_CONVERSION_FROM_ONE(_TYPE_, I) \
958 if constexpr(not std::is_same_v<TypeFrom, _TYPE_>) \
959 { \
960 knowCore::registerConverter<TypeFrom, _TYPE_>(); \
961 }
962
963#define __KNOWCORE_REGISTER_CONVERSION_FROM(_FACTORY_NAME_, _TYPE_FROM_, ...) \
964 namespace \
965 { \
966 class _FACTORY_NAME_ \
967 { \
968 public: \
969 _FACTORY_NAME_() \
970 { \
971 typedef _TYPE_FROM_ TypeFrom; \
972 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_CONVERSION_FROM_ONE, __VA_ARGS__) \
973 } \
974 static _FACTORY_NAME_ s_instance; \
975 }; \
976 _FACTORY_NAME_ _FACTORY_NAME_::s_instance; \
977 }
978
987#define KNOWCORE_REGISTER_CONVERSION_FROM(_TYPE_FROM_, ...) \
988 __KNOWCORE_REGISTER_CONVERSION_FROM(__KNOWCORE_UNIQUE_STATIC_NAME(MetaTypeRegisterConversion), \
989 _TYPE_FROM_, __VA_ARGS__)
990
991#define __KNOWCORE_REGISTER_CONVERSION_TO_ONE(_TYPE_, I) \
992 if constexpr(not std::is_same_v<_TYPE_, TypeTo>) \
993 { \
994 knowCore::registerConverter<_TYPE_, TypeTo>(); \
995 }
996
997#define __KNOWCORE_REGISTER_CONVERSION_TO(_FACTORY_NAME_, _TYPE_TO_, ...) \
998 namespace \
999 { \
1000 class _FACTORY_NAME_ \
1001 { \
1002 public: \
1003 _FACTORY_NAME_() \
1004 { \
1005 typedef _TYPE_TO_ TypeTo; \
1006 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_CONVERSION_TO_ONE, __VA_ARGS__) \
1007 } \
1008 static _FACTORY_NAME_ s_instance; \
1009 }; \
1010 _FACTORY_NAME_ _FACTORY_NAME_::s_instance; \
1011 }
1012
1021#define KNOWCORE_REGISTER_CONVERSION_TO(_TYPE_TO_, ...) \
1022 __KNOWCORE_REGISTER_CONVERSION_TO(__KNOWCORE_UNIQUE_STATIC_NAME(MetaTypeRegisterConversion), \
1023 _TYPE_TO_, __VA_ARGS__)
1024
1025// BEGIN KNOWCORE_REGISTER_COMPARATORS
1026
1027#define __KNOWCORE_REGISTER_COMPARATORS_FROM_ONE(_TYPE_, I) \
1028 knowCore::registerComparators<_LeftType_, _TYPE_, _comparators_...>();
1029
1030#define __KNOWCORE_REGISTER_COMPARATORS_MAKE_COMPARATOR_ONE(_COMPARATOR_, I) \
1031 , knowCore::ComparisonOperator::_COMPARATOR_
1032#define __KNOWCORE_REGISTER_COMPARATOR_MAKE_COMPARATORS(...) \
1033 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_COMPARATORS_MAKE_COMPARATOR_ONE, __VA_ARGS__)
1034
1035#define __KNOWCORE_REGISTER_COMPARATORS(_FACTORY_NAME_, _COMPARATORS_, _LEFT_, ...) \
1036 namespace \
1037 { \
1038 class _FACTORY_NAME_ \
1039 { \
1040 public: \
1041 _FACTORY_NAME_() \
1042 { \
1043 registerComparators< \
1044 _LEFT_ __KNOWCORE_REGISTER_COMPARATOR_MAKE_COMPARATORS _COMPARATORS_>(); \
1045 } \
1046 static _FACTORY_NAME_ s_instance; \
1047 private: \
1048 template<typename _LeftType_, knowCore::ComparisonOperator... _comparators_> \
1049 void registerComparators() \
1050 { \
1051 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_COMPARATORS_FROM_ONE, __VA_ARGS__) \
1052 } \
1053 }; \
1054 _FACTORY_NAME_ _FACTORY_NAME_::s_instance; \
1055 }
1056
1057#define KNOWCORE_REGISTER_COMPARATORS_FROM(_OPERATORS_, _LEFT_TYPE_, ...) \
1058 __KNOWCORE_REGISTER_COMPARATORS(__KNOWCORE_UNIQUE_STATIC_NAME(MetaTypeRegisterComparators), \
1059 _OPERATORS_, _LEFT_TYPE_, __VA_ARGS__)
1060
1061// END KNOWCORE_REGISTER_COMPARATOR
1062
1066#define KNOWCORE_REGISTER_COMPARATORS(_COMPARATORS_, _TYPE_) \
1067 KNOWCORE_REGISTER_COMPARATORS_FROM(_COMPARATORS_, _TYPE_, _TYPE_)
1068
1069// BEGIN KNOWCORE_REGISTER_ARITHMETIC_OPERATOR
1070
1071#define __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_FROM_ONE(_TYPE_, I) \
1072 knowCore::registerArithmeticOperators<_LeftType_, _TYPE_, _operators_...>();
1073
1074#define __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_MAKE_OPERATORS_ONE(_OPERATOR_, I) \
1075 , knowCore::ArithmeticOperator::_OPERATOR_
1076#define __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_MAKE_OPERATORS(...) \
1077 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_MAKE_OPERATORS_ONE, __VA_ARGS__)
1078
1079#define __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR(_FACTORY_NAME_, _OPERATORS_, _LEFT_, ...) \
1080 namespace \
1081 { \
1082 class _FACTORY_NAME_ \
1083 { \
1084 public: \
1085 _FACTORY_NAME_() \
1086 { \
1087 registerArithmeticOperators< \
1088 _LEFT_ __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_MAKE_OPERATORS _OPERATORS_>(); \
1089 } \
1090 static _FACTORY_NAME_ s_instance; \
1091 private: \
1092 template<typename _LeftType_, ArithmeticOperator... _operators_> \
1093 void registerArithmeticOperators() \
1094 { \
1095 KNOWCORE_FOREACH(__KNOWCORE_REGISTER_ARITHMETIC_OPERATOR_FROM_ONE, __VA_ARGS__) \
1096 } \
1097 }; \
1098 _FACTORY_NAME_ _FACTORY_NAME_::s_instance; \
1099 }
1100
1101#define KNOWCORE_REGISTER_ARITHMETIC_OPERATORS(_OPERATORS_, _LEFT_TYPE_, ...) \
1102 __KNOWCORE_REGISTER_ARITHMETIC_OPERATOR( \
1103 __KNOWCORE_UNIQUE_STATIC_NAME(MetaTypeRegisterArithmeticOperator), _OPERATORS_, _LEFT_TYPE_, \
1104 __VA_ARGS__)
1105
1106// END KNOWCORE_REGISTER_ARITHMETIC_OPERATOR
1107
1108#define KNOWCORE_DEFINE_METATYPE_START_IMPLEMENTATION_TEMPLATE(_TYPE_) \
1109 class knowCore::MetaTypeDefinition<_TYPE_> \
1110 : public knowCore::MetaTypeDefinitionImplementation<_TYPE_> \
1111 { \
1112 template<typename _TT_, typename _ENABLED_> \
1113 friend class knowCore::MetaTypeDefinition; \
1114 using knowCore::MetaTypeDefinitionImplementation<_TYPE_>::expectedError; \
1115 using knowCore::MetaTypeDefinitionImplementation<_TYPE_>::expectedObjectError; \
1116 using knowCore::MetaTypeDefinitionImplementation<_TYPE_>::expectedArrayError; \
1117 using knowCore::MetaTypeDefinitionImplementation<_TYPE_>::toJsonString; \
1118 using knowCore::MetaTypeDefinitionImplementation<_TYPE_>::fromJsonString; \
1119 protected:
1120
1121#define KNOWCORE_DEFINE_METATYPE_FINISH_IMPLEMENTATION(_TYPE_) \
1122 } \
1123 ;
1124
1125#define KNOWCORE_DEFINE_METATYPE_START_IMPLEMENTATION(_TYPE_) \
1126 template<> \
1127 KNOWCORE_DEFINE_METATYPE_START_IMPLEMENTATION_TEMPLATE(_TYPE_)
1128
1129#define __KNOWCORE_URIFY(_URI_, I) knowCore::Details::makeUri(_URI_),
1130
1131#define __KNOWCORE_URIFY_LIST(...) KNOWCORE_FOREACH(__KNOWCORE_URIFY, __VA_ARGS__)
1132
1133#define __KNOWCORE_DEFINE_METATYPE_ALIASES__INTERNAL__(_FACTORY_NAME_, ...) \
1134 namespace \
1135 { \
1136 class _FACTORY_NAME_ \
1137 { \
1138 public: \
1139 _FACTORY_NAME_() \
1140 { \
1141 QList<knowCore::Uri> uris = {__KNOWCORE_URIFY_LIST(__VA_ARGS__)}; \
1142 clog_assert(uris.size() > 0); \
1143 knowCore::Uri to = uris.takeLast(); \
1144 knowCore::registerMetaTypeAliases(uris, to); \
1145 } \
1146 static _FACTORY_NAME_ s_instance; \
1147 }; \
1148 _FACTORY_NAME_ _FACTORY_NAME_::s_instance; \
1149 }
1150
1160#define KNOWCORE_DEFINE_METATYPE_ALIASES(...) \
1161 __KNOWCORE_DEFINE_METATYPE_ALIASES__INTERNAL__(__KNOWCORE_UNIQUE_STATIC_NAME(MetaTypeAlias), \
1162 __VA_ARGS__)
1163
QList
Definition Forward.h:14
knowCore::AbstractArithmeticOperator
Definition MetaType.h:281
knowCore::AbstractMetaTypeDefinition
Definition MetaType.h:200
knowCore::AbstractToVariantMarshal
Definition MetaTypeImplementation.h:380
knowCore::AbstractTypeComparator
Definition MetaType.h:272
knowCore::AbstractTypeConversion
Definition MetaType.h:264
knowCore::BigNumber
Class that can contains large numeric value.
Definition BigNumber.h:51
knowCore::DeserialisationContexts
Definition MetaType.h:126
knowCore::DeserialisationContexts::getContext
cres_qresult< AbstractDeserialisationContext * > getContext(const knowCore::Uri &_uri) const
Definition MetaType.cpp:74
knowCore::Details::RegisterConverter
Definition MetaTypeImplementation.h:828
knowCore::MetaTypeDefinitionImplementation
Definition MetaTypeImplementation.h:542
knowCore::MetaTypeDefinitionImplementation::fromCborValue
cres_qresult< void > fromCborValue(void *_value, const QCborValue &_cbor_value, const DeserialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:671
knowCore::MetaTypeDefinitionImplementation::qMetaTypeId
int qMetaTypeId() const override
Definition MetaTypeImplementation.h:572
knowCore::MetaTypeDefinitionImplementation::toCborValue
cres_qresult< QCborValue > toCborValue(const void *_value, const SerialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:666
knowCore::MetaTypeDefinitionImplementation::md5
cres_qresult< QByteArray > md5(const void *_value) const override
Definition MetaTypeImplementation.h:652
knowCore::MetaTypeDefinitionImplementation::toJsonValue
cres_qresult< QJsonValue > toJsonValue(const void *_value, const SerialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:656
knowCore::MetaTypeDefinitionImplementation::toRdfLiteral
cres_qresult< QString > toRdfLiteral(const void *_value, const SerialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:680
knowCore::MetaTypeDefinitionImplementation::fromRdfLiteral
cres_qresult< void > fromRdfLiteral(void *_value, const QString &_serialised, const DeserialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:685
knowCore::MetaTypeDefinitionImplementation::fromJsonValue
cres_qresult< void > fromJsonValue(void *_value, const QJsonValue &_json_value, const DeserialisationContexts &_contexts) const override
Definition MetaTypeImplementation.h:661
knowCore::MetaTypeDefinitionImplementation::printable
cres_qresult< QString > printable(const void *_value) const override
Definition MetaTypeImplementation.h:676
knowCore::MetaTypeDefinition
Definition MetaType.h:361
knowCore::MetaTypeInformation
Definition MetaType.h:66
knowCore::SerialisationContexts
Definition MetaType.h:159
knowCore::SerialisationContexts::getContext
cres_qresult< AbstractSerialisationContext * > getContext(const knowCore::Uri &_uri) const
Definition MetaType.cpp:111
knowCore::Uri
Definition Uri.h:15
knowCore::Value
Definition Value.h:21
knowCore::Value::fromValue
static Value fromValue(const _T_ &_value)
Definition Value.h:241
knowCore::details::MoreDetails
Definition MetaTypeImplementation.h:203
knowCore::details::ToVariantMarshalImplementation
Definition MetaTypeImplementation.h:394
knowCore::details::EqualComparableRV
Definition MetaTypeImplementation.h:94
knowCore::details::EqualComparable
Definition MetaTypeImplementation.h:86
knowCore::details::HasConversionMode
Definition MetaTypeImplementation.h:440
knowCore::details::HasToVariant
Definition MetaTypeImplementation.h:388
knowCore::details::InferiorComparableRV
Definition MetaTypeImplementation.h:98
knowCore::details::InferiorComparable
Definition MetaTypeImplementation.h:90
knowCore::details::arithmetic
Definition MetaTypeImplementation.h:185
knowCore::details::is_integral
Definition MetaTypeImplementation.h:102
knowCore::details::left_signed_right_unsigned
Definition MetaTypeImplementation.h:110
knowCore::details::left_unsigned_right_signed
Definition MetaTypeImplementation.h:106
knowCore::ArithmeticOperation
Definition MetaTypeImplementation.h:58
knowCore::Comparator
Definition MetaTypeImplementation.h:56
knowCore::Converter
Definition MetaTypeImplementation.h:54
knowCore::Details::RegisterFromListConverter
Definition MetaTypeImplementation.h:844
knowCore::Details::RegisterNumericDataType
Definition MetaTypeImplementation.h:877
knowCore::Details::RegisterToListConverter
Definition MetaTypeImplementation.h:860
knowCore::details::ArtithmeticOperatorImplementation
Definition MetaTypeImplementation.h:308
knowCore::details::ComparatorComparatorImplementation
Definition MetaTypeImplementation.h:297
knowCore::details::ConvertConversionImplementation
Definition MetaTypeImplementation.h:274
knowCore::details::FromValueListConversionImplementation
Definition MetaTypeImplementation.h:229
knowCore::details::ToValueListConversionImplementation
Definition MetaTypeImplementation.h:252
knowCore::details::TypeComparatorImplementation
Definition MetaTypeImplementation.h:282
knowCore::details::TypeConversionImplementation
Definition MetaTypeImplementation.h:213
knowCore::details::op_trait
Definition MetaTypeImplementation.h:161
Generated by doxygen 1.12.0