add flatbuffers support and initial rewrite
Signed-off-by: Folling <mail@folling.io>
This commit is contained in:
Folling
parent
7e883d24eb
commit
98cb7a44ef
72 changed files with 3929 additions and 1403 deletions
|
|
@ -1,7 +1 @@
|
|||
#pragma once
|
||||
|
||||
struct IkarusEntityPropertyValue {
|
||||
struct IkarusEntity const * entity;
|
||||
struct IkarusProperty const * property;
|
||||
struct IkarusValue const * value;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -6,60 +6,60 @@
|
|||
#include <ikarus/values/value_base.hpp>
|
||||
|
||||
IkarusNumberValue::IkarusNumberValue():
|
||||
IkarusValue{this} {}
|
||||
IkarusValueData{this} {}
|
||||
|
||||
IkarusNumberValue * ikarus_number_value_create() {
|
||||
IkarusNumberValue * ikarus_number_value_data_create() {
|
||||
return new IkarusNumberValue{};
|
||||
}
|
||||
|
||||
double const * ikarus_number_value_get(IkarusNumberValue * value, size_t idx) {
|
||||
return ikarus_value_base_get(value, idx);
|
||||
double const * ikarus_number_value_data_get(IkarusNumberValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_get(value, idx);
|
||||
}
|
||||
|
||||
size_t ikarus_number_value_get_size(IkarusNumberValue const * value) {
|
||||
return ikarus_value_base_get_size(value);
|
||||
size_t ikarus_number_value_data_get_size(IkarusNumberValue const * value) {
|
||||
return ikarus_value_data_base_get_size(value);
|
||||
}
|
||||
|
||||
void ikarus_number_value_set(IkarusNumberValue * value, size_t idx, double new_data) {
|
||||
return ikarus_value_base_set(value, idx, new_data);
|
||||
void ikarus_number_value_data_set(IkarusNumberValue * value, size_t idx, double new_data) {
|
||||
return ikarus_value_data_base_set(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_number_value_remove(IkarusNumberValue * value, size_t idx) {
|
||||
return ikarus_value_base_remove(value, idx);
|
||||
void ikarus_number_value_data_remove(IkarusNumberValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_remove(value, idx);
|
||||
}
|
||||
|
||||
void ikarus_number_value_insert(IkarusNumberValue * value, size_t idx, long double new_data) {
|
||||
return ikarus_value_base_insert(value, idx, new_data);
|
||||
void ikarus_number_value_data_insert(IkarusNumberValue * value, size_t idx, long double new_data) {
|
||||
return ikarus_value_data_base_insert(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_number_value_clear(IkarusNumberValue * value) {
|
||||
return ikarus_value_base_clear(value);
|
||||
void ikarus_number_value_data_clear(IkarusNumberValue * value) {
|
||||
return ikarus_value_data_base_clear(value);
|
||||
}
|
||||
|
||||
bool ikarus_number_value_is_undefined(IkarusNumberValue const * value) {
|
||||
return ikarus_value_base_is_undefined(value);
|
||||
bool ikarus_number_value_data_is_undefined(IkarusNumberValue const * value) {
|
||||
return ikarus_value_data_base_is_undefined(value);
|
||||
}
|
||||
|
||||
void ikarus_number_value_set_undefined(IkarusNumberValue * value, bool undefined) {
|
||||
return ikarus_value_base_set_undefined(value, undefined);
|
||||
void ikarus_number_value_data_set_undefined(IkarusNumberValue * value, bool undefined) {
|
||||
return ikarus_value_data_base_set_undefined(value, undefined);
|
||||
}
|
||||
|
||||
char const * ikarus_number_value_to_string(IkarusNumberValue const * value) {
|
||||
return ikarus_value_base_to_string(value, [](auto const & value) { return value; });
|
||||
char const * ikarus_number_value_data_to_string(IkarusNumberValue const * value) {
|
||||
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value; });
|
||||
}
|
||||
|
||||
bool ikarus_number_value_is_equal(IkarusNumberValue const * lhs, IkarusNumberValue const * rhs) {
|
||||
return ikarus_value_base_is_equal(lhs, rhs);
|
||||
bool ikarus_number_value_data_is_equal(IkarusNumberValue const * lhs, IkarusNumberValue const * rhs) {
|
||||
return ikarus_value_data_base_is_equal(lhs, rhs);
|
||||
}
|
||||
|
||||
IkarusNumberValue * ikarus_number_value_copy(IkarusNumberValue const * value) {
|
||||
return ikarus_value_base_copy(value);
|
||||
IkarusNumberValue * ikarus_number_value_data_copy(IkarusNumberValue const * value) {
|
||||
return ikarus_value_data_base_copy(value);
|
||||
}
|
||||
|
||||
struct IkarusValue * ikarus_number_value_to_value(IkarusNumberValue * value) {
|
||||
return ikarus_value_base_to_value(value);
|
||||
struct IkarusValueData * ikarus_number_value_data_to_value(IkarusNumberValue * value) {
|
||||
return ikarus_value_data_base_to_value(value);
|
||||
}
|
||||
|
||||
struct IkarusValue const * ikarus_number_value_to_value_const(IkarusNumberValue const * value) {
|
||||
return ikarus_value_base_to_value_const(value);
|
||||
struct IkarusValueData const * ikarus_number_value_data_to_value_data_const(IkarusNumberValue const * value) {
|
||||
return ikarus_value_data_base_to_value_data_const(value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
#include <ikarus/values/value.hpp>
|
||||
|
||||
struct IkarusNumberValue : IkarusValue {
|
||||
struct IkarusNumberValue : IkarusValueData {
|
||||
public:
|
||||
using DataType = double;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,60 +7,60 @@
|
|||
#include <ikarus/values/value_base.hpp>
|
||||
|
||||
IkarusTextValue::IkarusTextValue():
|
||||
IkarusValue{this} {}
|
||||
IkarusValueData{this} {}
|
||||
|
||||
IkarusTextValue * ikarus_text_value_create() {
|
||||
IkarusTextValue * ikarus_text_value_data_create() {
|
||||
return new IkarusTextValue{};
|
||||
}
|
||||
|
||||
char const * ikarus_text_value_get(IkarusTextValue * value, size_t idx) {
|
||||
return ikarus_value_base_get(value, idx)->data();
|
||||
char const * ikarus_text_value_data_get(IkarusTextValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_get(value, idx)->data();
|
||||
}
|
||||
|
||||
size_t ikarus_text_value_get_size(IkarusTextValue const * value) {
|
||||
return ikarus_value_base_get_size(value);
|
||||
size_t ikarus_text_value_data_get_size(IkarusTextValue const * value) {
|
||||
return ikarus_value_data_base_get_size(value);
|
||||
}
|
||||
|
||||
void ikarus_text_value_set(IkarusTextValue * value, size_t idx, char const * new_data) {
|
||||
return ikarus_value_base_set(value, idx, new_data);
|
||||
void ikarus_text_value_data_set(IkarusTextValue * value, size_t idx, char const * new_data) {
|
||||
return ikarus_value_data_base_set(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_text_value_remove(IkarusTextValue * value, size_t idx) {
|
||||
return ikarus_value_base_remove(value, idx);
|
||||
void ikarus_text_value_data_remove(IkarusTextValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_remove(value, idx);
|
||||
}
|
||||
|
||||
void ikarus_text_value_insert(IkarusTextValue * value, size_t idx, char const * new_data) {
|
||||
return ikarus_value_base_insert(value, idx, new_data);
|
||||
void ikarus_text_value_data_insert(IkarusTextValue * value, size_t idx, char const * new_data) {
|
||||
return ikarus_value_data_base_insert(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_text_value_clear(IkarusTextValue * value) {
|
||||
return ikarus_value_base_clear(value);
|
||||
void ikarus_text_value_data_clear(IkarusTextValue * value) {
|
||||
return ikarus_value_data_base_clear(value);
|
||||
}
|
||||
|
||||
bool ikarus_text_value_is_undefined(IkarusTextValue const * value) {
|
||||
return ikarus_value_base_is_undefined(value);
|
||||
bool ikarus_text_value_data_is_undefined(IkarusTextValue const * value) {
|
||||
return ikarus_value_data_base_is_undefined(value);
|
||||
}
|
||||
|
||||
void ikarus_text_value_set_undefined(IkarusTextValue * value, bool undefined) {
|
||||
return ikarus_value_base_set_undefined(value, undefined);
|
||||
void ikarus_text_value_data_set_undefined(IkarusTextValue * value, bool undefined) {
|
||||
return ikarus_value_data_base_set_undefined(value, undefined);
|
||||
}
|
||||
|
||||
char const * ikarus_text_value_to_string(IkarusTextValue const * value) {
|
||||
return ikarus_value_base_to_string(value, [](auto const & value) { return value; });
|
||||
char const * ikarus_text_value_data_to_string(IkarusTextValue const * value) {
|
||||
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value; });
|
||||
}
|
||||
|
||||
bool ikarus_text_value_is_equal(IkarusTextValue const * lhs, IkarusTextValue const * rhs) {
|
||||
return ikarus_value_base_is_equal(lhs, rhs);
|
||||
bool ikarus_text_value_data_is_equal(IkarusTextValue const * lhs, IkarusTextValue const * rhs) {
|
||||
return ikarus_value_data_base_is_equal(lhs, rhs);
|
||||
}
|
||||
|
||||
IkarusTextValue * ikarus_text_value_copy(IkarusTextValue const * value) {
|
||||
return ikarus_value_base_copy(value);
|
||||
IkarusTextValue * ikarus_text_value_data_copy(IkarusTextValue const * value) {
|
||||
return ikarus_value_data_base_copy(value);
|
||||
}
|
||||
|
||||
struct IkarusValue * ikarus_text_value_to_value(IkarusTextValue * value) {
|
||||
return ikarus_value_base_to_value(value);
|
||||
struct IkarusValueData * ikarus_text_value_data_to_value(IkarusTextValue * value) {
|
||||
return ikarus_value_data_base_to_value(value);
|
||||
}
|
||||
|
||||
struct IkarusValue const * ikarus_text_value_to_value_const(IkarusTextValue const * value) {
|
||||
return ikarus_value_base_to_value_const(value);
|
||||
struct IkarusValueData const * ikarus_text_value_data_to_value_data_const(IkarusTextValue const * value) {
|
||||
return ikarus_value_data_base_to_value_data_const(value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
#include <ikarus/values/value.hpp>
|
||||
|
||||
struct IkarusTextValue : IkarusValue {
|
||||
struct IkarusTextValue : IkarusValueData {
|
||||
public:
|
||||
using DataType = std::string;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,60 +7,60 @@
|
|||
#include <ikarus/values/value_base.hpp>
|
||||
|
||||
IkarusToggleValue::IkarusToggleValue():
|
||||
IkarusValue{this} {}
|
||||
IkarusValueData{this} {}
|
||||
|
||||
IkarusToggleValue * ikarus_toggle_value_create() {
|
||||
IkarusToggleValue * ikarus_toggle_value_data_create() {
|
||||
return new IkarusToggleValue{};
|
||||
}
|
||||
|
||||
bool const * ikarus_toggle_value_get(IkarusToggleValue * value, size_t idx) {
|
||||
return ikarus_value_base_get(value, idx);
|
||||
bool const * ikarus_toggle_value_data_get(IkarusToggleValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_get(value, idx);
|
||||
}
|
||||
|
||||
size_t ikarus_toggle_value_get_size(IkarusToggleValue const * value) {
|
||||
return ikarus_value_base_get_size(value);
|
||||
size_t ikarus_toggle_value_data_get_size(IkarusToggleValue const * value) {
|
||||
return ikarus_value_data_base_get_size(value);
|
||||
}
|
||||
|
||||
void ikarus_toggle_value_set(IkarusToggleValue * value, size_t idx, bool new_data) {
|
||||
return ikarus_value_base_set(value, idx, new_data);
|
||||
void ikarus_toggle_value_data_set(IkarusToggleValue * value, size_t idx, bool new_data) {
|
||||
return ikarus_value_data_base_set(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_toggle_value_remove(IkarusToggleValue * value, size_t idx) {
|
||||
return ikarus_value_base_remove(value, idx);
|
||||
void ikarus_toggle_value_data_remove(IkarusToggleValue * value, size_t idx) {
|
||||
return ikarus_value_data_base_remove(value, idx);
|
||||
}
|
||||
|
||||
void ikarus_toggle_value_insert(IkarusToggleValue * value, size_t idx, bool new_data) {
|
||||
return ikarus_value_base_insert(value, idx, new_data);
|
||||
void ikarus_toggle_value_data_insert(IkarusToggleValue * value, size_t idx, bool new_data) {
|
||||
return ikarus_value_data_base_insert(value, idx, new_data);
|
||||
}
|
||||
|
||||
void ikarus_toggle_value_clear(IkarusToggleValue * value) {
|
||||
return ikarus_value_base_clear(value);
|
||||
void ikarus_toggle_value_data_clear(IkarusToggleValue * value) {
|
||||
return ikarus_value_data_base_clear(value);
|
||||
}
|
||||
|
||||
bool ikarus_toggle_value_is_undefined(IkarusToggleValue const * value) {
|
||||
return ikarus_value_base_is_undefined(value);
|
||||
bool ikarus_toggle_value_data_is_undefined(IkarusToggleValue const * value) {
|
||||
return ikarus_value_data_base_is_undefined(value);
|
||||
}
|
||||
|
||||
void ikarus_toggle_value_set_undefined(IkarusToggleValue * value, bool undefined) {
|
||||
return ikarus_value_base_set_undefined(value, undefined);
|
||||
void ikarus_toggle_value_data_set_undefined(IkarusToggleValue * value, bool undefined) {
|
||||
return ikarus_value_data_base_set_undefined(value, undefined);
|
||||
}
|
||||
|
||||
char const * ikarus_toggle_value_to_string(IkarusToggleValue const * value) {
|
||||
return ikarus_value_base_to_string(value, [](auto const & value) { return value ? "✓" : "✗"; });
|
||||
char const * ikarus_toggle_value_data_to_string(IkarusToggleValue const * value) {
|
||||
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value ? "✓" : "✗"; });
|
||||
}
|
||||
|
||||
bool ikarus_toggle_value_is_equal(IkarusToggleValue const * lhs, IkarusToggleValue const * rhs) {
|
||||
return ikarus_value_base_is_equal(lhs, rhs);
|
||||
bool ikarus_toggle_value_data_is_equal(IkarusToggleValue const * lhs, IkarusToggleValue const * rhs) {
|
||||
return ikarus_value_data_base_is_equal(lhs, rhs);
|
||||
}
|
||||
|
||||
IkarusToggleValue * ikarus_toggle_value_copy(IkarusToggleValue const * value) {
|
||||
return ikarus_value_base_copy(value);
|
||||
IkarusToggleValue * ikarus_toggle_value_data_copy(IkarusToggleValue const * value) {
|
||||
return ikarus_value_data_base_copy(value);
|
||||
}
|
||||
|
||||
struct IkarusValue * ikarus_toggle_value_to_value(IkarusToggleValue * value) {
|
||||
return ikarus_value_base_to_value(value);
|
||||
struct IkarusValueData * ikarus_toggle_value_data_to_value(IkarusToggleValue * value) {
|
||||
return ikarus_value_data_base_to_value(value);
|
||||
}
|
||||
|
||||
struct IkarusValue const * ikarus_toggle_value_to_value_const(IkarusToggleValue const * value) {
|
||||
return ikarus_value_base_to_value_const(value);
|
||||
struct IkarusValueData const * ikarus_toggle_value_data_to_value_data_const(IkarusToggleValue const * value) {
|
||||
return ikarus_value_data_base_to_value_data_const(value);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
#include <ikarus/values/value.hpp>
|
||||
|
||||
struct IkarusToggleValue : IkarusValue {
|
||||
struct IkarusToggleValue : IkarusValueData {
|
||||
public:
|
||||
using DataType = bool;
|
||||
|
||||
|
|
|
|||
|
|
@ -3,41 +3,53 @@
|
|||
#include <string>
|
||||
|
||||
#include <boost/container/small_vector.hpp>
|
||||
|
||||
// required for header-only inclusion
|
||||
#include "cppbase/templates.hpp"
|
||||
|
||||
#include <boost/json/src.hpp>
|
||||
|
||||
#include <ikarus/objects/properties/property_type.h>
|
||||
// required for header-only inclusion
|
||||
#include <cppbase/templates.hpp>
|
||||
|
||||
#include <ikarus/values/number_value.hpp>
|
||||
#include <ikarus/values/text_value.hpp>
|
||||
#include <ikarus/values/toggle_value.hpp>
|
||||
#include <ikarus/values/value.hpp>
|
||||
#include <ikarus/values/value_cardinality.h>
|
||||
#include <ikarus/values/value_type.h>
|
||||
|
||||
IkarusValue::IkarusValue(Data data):
|
||||
data(data) {}
|
||||
IkarusValue::IkarusValue(Data data, IkarusValueCardinality cardinality):
|
||||
data{data},
|
||||
cardinality{cardinality} {}
|
||||
|
||||
cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_json(boost::json::value json) {
|
||||
if (auto const * obj = json.if_object(); obj == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
} else {
|
||||
boost::int64_t const * type = nullptr;
|
||||
boost::json::value const * data = nullptr;
|
||||
int64_t const * type;
|
||||
int64_t const * cardinality;
|
||||
boost::json::value const * data;
|
||||
|
||||
if (auto const * type_value = obj->if_contains("type"); type_value == nullptr) {
|
||||
if (auto const * type_value = obj->if_contains(IKARUS_VALUE_JSON_TYPE_KEY); type_value == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
} else if (type = type_value->if_int64(); type == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
}
|
||||
|
||||
if (data = obj->if_contains("data"); data == nullptr) {
|
||||
if (auto const * cardinality_value = obj->if_contains(IKARUS_VALUE_JSON_CARDINALITY_KEY); cardinality_value == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
} else if (cardinality = cardinality_value->if_int64(); cardinality == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
} else if (*cardinality != IkarusValueCardinality_Single && *cardinality != IkarusValueCardinality_Multiple) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
}
|
||||
|
||||
auto create_value = [data]<typename T>() -> cppbase::Result<IkarusValue *, FromJsonError> {
|
||||
if (data = obj->if_contains(IKARUS_VALUE_JSON_DATA_KEY); data == nullptr) {
|
||||
return cppbase::err(FromJsonError{});
|
||||
}
|
||||
|
||||
auto create_value = [data, cardinality]<typename T>() -> cppbase::Result<IkarusValue *, FromJsonError> {
|
||||
T * ret = nullptr;
|
||||
|
||||
ret->cardinality = *cardinality;
|
||||
|
||||
if (data->is_null()) {
|
||||
ret = new T{};
|
||||
ret->data = boost::variant2::monostate{};
|
||||
|
|
@ -58,13 +70,13 @@ cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_jso
|
|||
};
|
||||
|
||||
switch (*type) {
|
||||
case IkarusPropertyType_Toggle: {
|
||||
case IkarusValueType_Toggle: {
|
||||
return create_value.operator()<IkarusToggleValue>();
|
||||
}
|
||||
case IkarusPropertyType_Number: {
|
||||
case IkarusValueType_Number: {
|
||||
return create_value.operator()<IkarusNumberValue>();
|
||||
}
|
||||
case IkarusPropertyType_Text: {
|
||||
case IkarusValueType_Text: {
|
||||
return create_value.operator()<IkarusTextValue>();
|
||||
}
|
||||
default: {
|
||||
|
|
@ -75,18 +87,18 @@ cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_jso
|
|||
}
|
||||
|
||||
boost::json::value IkarusValue::to_json() const {
|
||||
auto type = boost::variant2::visit(
|
||||
auto type = std::visit(
|
||||
cppbase::overloaded{
|
||||
[]([[maybe_unused]] IkarusToggleValue const * value) { return IkarusPropertyType_Toggle; },
|
||||
[]([[maybe_unused]] IkarusNumberValue const * value) { return IkarusPropertyType_Number; },
|
||||
[]([[maybe_unused]] IkarusTextValue const * value) { return IkarusPropertyType_Text; }
|
||||
[]([[maybe_unused]] IkarusToggleValue const * value) { return IkarusValueType_Toggle; },
|
||||
[]([[maybe_unused]] IkarusNumberValue const * value) { return IkarusValueType_Number; },
|
||||
[]([[maybe_unused]] IkarusTextValue const * value) { return IkarusValueType_Text; }
|
||||
},
|
||||
data
|
||||
);
|
||||
|
||||
auto data_json = boost::variant2::visit(
|
||||
auto data_json = std::visit(
|
||||
[]<typename T>(T const * value) -> boost::json::value {
|
||||
return boost::variant2::visit(
|
||||
return std::visit(
|
||||
cppbase::overloaded{
|
||||
[]([[maybe_unused]] boost::variant2::monostate const & data) -> boost::json::value { return nullptr; },
|
||||
[](auto const & data) -> boost::json::value { return boost::json::value_from(data); }
|
||||
|
|
@ -98,8 +110,9 @@ boost::json::value IkarusValue::to_json() const {
|
|||
);
|
||||
|
||||
return {
|
||||
{"type", type},
|
||||
{"data", data_json}
|
||||
{ IKARUS_VALUE_JSON_TYPE_KEY, type},
|
||||
{IKARUS_VALUE_JSON_CARDINALITY_KEY, cardinality},
|
||||
{ IKARUS_VALUE_JSON_DATA_KEY, data_json}
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -110,7 +123,7 @@ void ikarus_value_visit(
|
|||
void (*text_visitor)(IkarusTextValue *, void *),
|
||||
void * data
|
||||
) {
|
||||
boost::variant2::visit(
|
||||
std::visit(
|
||||
cppbase::overloaded{
|
||||
[toggle_visitor, data](IkarusToggleValue * toggle_value) { toggle_visitor(toggle_value, data); },
|
||||
[number_visitor, data](IkarusNumberValue * number_value) { number_visitor(number_value, data); },
|
||||
|
|
@ -119,20 +132,3 @@ void ikarus_value_visit(
|
|||
value->data
|
||||
);
|
||||
}
|
||||
|
||||
void ikarus_value_visit_const(
|
||||
IkarusValue const * value,
|
||||
void (*toggle_visitor)(IkarusToggleValue const *, void *),
|
||||
void (*number_visitor)(IkarusNumberValue const *, void *),
|
||||
void (*text_visitor)(IkarusTextValue const *, void *),
|
||||
void * data
|
||||
) {
|
||||
boost::variant2::visit(
|
||||
cppbase::overloaded{
|
||||
[toggle_visitor, data](IkarusToggleValue const * toggle_value) { toggle_visitor(toggle_value, data); },
|
||||
[number_visitor, data](IkarusNumberValue const * number_value) { number_visitor(number_value, data); },
|
||||
[text_visitor, data](IkarusTextValue const * text_value) { text_visitor(text_value, data); }
|
||||
},
|
||||
value->data
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,20 +1,24 @@
|
|||
#pragma once
|
||||
|
||||
#include <boost/json.hpp>
|
||||
#include <boost/variant2.hpp>
|
||||
|
||||
#include <cppbase/result.hpp>
|
||||
|
||||
#include <ikarus/errors.hpp>
|
||||
#include <ikarus/persistence/project.hpp>
|
||||
#include <ikarus/values/value_cardinality.h>
|
||||
|
||||
constexpr auto IKARUS_VALUE_JSON_TYPE_KEY = "type";
|
||||
constexpr auto IKARUS_VALUE_JSON_CARDINALITY_KEY = "card";
|
||||
constexpr auto IKARUS_VALUE_JSON_DATA_KEY = "data";
|
||||
|
||||
struct IkarusValue {
|
||||
public:
|
||||
using Data = boost::variant2::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>;
|
||||
using Data = std::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>;
|
||||
constexpr static auto SMALL_VEC_VALUE_SIZE = 8;
|
||||
|
||||
public:
|
||||
explicit IkarusValue(Data data);
|
||||
explicit IkarusValue(Data data, IkarusValueCardinality cardinality);
|
||||
|
||||
IkarusValue(IkarusValue const &) = default;
|
||||
IkarusValue(IkarusValue &&) noexcept = default;
|
||||
|
|
@ -32,6 +36,7 @@ public:
|
|||
|
||||
public:
|
||||
Data data;
|
||||
IkarusValueCardinality cardinality;
|
||||
};
|
||||
|
||||
template<>
|
||||
|
|
@ -74,3 +79,20 @@ IkarusValue * fetch_value_from_db(IkarusProject * project, IkarusErrorData * err
|
|||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define IKARUS_FAIL_IF_VALUE_MISSING_IMPL(var_name, entity, name, ret) \
|
||||
IKARUS_VTRYRV_OR_FAIL( \
|
||||
bool const var_name, \
|
||||
ret, \
|
||||
"unable to check whether value exists: {}", \
|
||||
IkarusErrorInfo_Database_QueryFailed, \
|
||||
(entity)->project->db->template query_one<bool>( \
|
||||
"SELECT EXISTS(SELECT 1 FROM `entity_values` WHERE `entity` = ? AND `name` = ?)", \
|
||||
(entity)->id, \
|
||||
name \
|
||||
) \
|
||||
) \
|
||||
\
|
||||
IKARUS_FAIL_IF(!(var_name), ret, "entity value does not exist", IkarusErrorInfo_Client_Misuse);
|
||||
|
||||
#define IKARUS_FAIL_IF_VALUE_MISSING(entity, name, ret) IKARUS_FAIL_IF_VALUE_MISSING_IMPL(CPPBASE_UNIQUE_NAME(exists), entity, name, ret);
|
||||
|
|
|
|||
|
|
@ -7,9 +7,10 @@
|
|||
#include <cppbase/templates.hpp>
|
||||
|
||||
template<typename V>
|
||||
typename V::DataType const * ikarus_value_base_get(V * value, size_t idx) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
typename V::DataType const * ikarus_value_data_base_get(V * value, size_t idx) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
return &(*data)[idx];
|
||||
}
|
||||
|
|
@ -18,9 +19,10 @@ typename V::DataType const * ikarus_value_base_get(V * value, size_t idx) {
|
|||
}
|
||||
|
||||
template<typename V>
|
||||
size_t ikarus_value_base_get_size(V const * value) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
size_t ikarus_value_data_base_get_size(V const * value) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
return data->size();
|
||||
}
|
||||
|
|
@ -29,57 +31,61 @@ size_t ikarus_value_base_get_size(V const * value) {
|
|||
}
|
||||
|
||||
template<typename V>
|
||||
void ikarus_value_base_set(V * value, size_t idx, typename V::DataType new_data) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
void ikarus_value_data_base_set(V * value, size_t idx, typename V::DataType new_data) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
(*data)[idx] = new_data;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
void ikarus_value_base_remove(V * value, size_t idx) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
void ikarus_value_data_base_remove(V * value, size_t idx) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
data->erase(data->begin() + idx);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
void ikarus_value_base_insert(V * value, size_t idx, typename V::DataType new_data) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
void ikarus_value_data_base_insert(V * value, size_t idx, typename V::DataType new_data) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
data->insert(data->begin() + idx, new_data);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
void ikarus_value_base_clear(V * value) {
|
||||
if (auto * data =
|
||||
boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(&value->data);
|
||||
void ikarus_value_data_base_clear(V * value) {
|
||||
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
|
||||
&value->data
|
||||
);
|
||||
data != nullptr) {
|
||||
data->clear();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
bool ikarus_value_base_is_undefined(V const * value) {
|
||||
bool ikarus_value_data_base_is_undefined(V const * value) {
|
||||
return boost::variant2::holds_alternative<boost::variant2::monostate>(value->data);
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
void ikarus_value_base_set_undefined(V * value, bool undefined) {
|
||||
void ikarus_value_data_base_set_undefined(V * value, bool undefined) {
|
||||
if (undefined) {
|
||||
value->data = boost::variant2::monostate{};
|
||||
} else {
|
||||
value->data = boost::container::small_vector<typename V::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>{};
|
||||
value->data = boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>{};
|
||||
}
|
||||
}
|
||||
|
||||
template<typename V, std::invocable<typename V::DataType> F>
|
||||
char const * ikarus_value_base_to_string(V const * value, F transformer) {
|
||||
char const * ikarus_value_data_base_to_string(V const * value, F transformer) {
|
||||
return boost::variant2::visit(
|
||||
cppbase::overloaded{
|
||||
[](boost::variant2::monostate const &) -> char const * { return nullptr; },
|
||||
|
|
@ -100,21 +106,21 @@ char const * ikarus_value_base_to_string(V const * value, F transformer) {
|
|||
}
|
||||
|
||||
template<typename V>
|
||||
bool ikarus_value_base_is_equal(V const * lhs, V const * rhs) {
|
||||
bool ikarus_value_data_base_is_equal(V const * lhs, V const * rhs) {
|
||||
return lhs->data == rhs->data;
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
V * ikarus_value_base_copy(V const * value) {
|
||||
V * ikarus_value_data_base_copy(V const * value) {
|
||||
return new V{*value};
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
struct IkarusValue * ikarus_value_base_to_value(V * value) {
|
||||
return static_cast<IkarusValue *>(value);
|
||||
struct IkarusValueData * ikarus_value_data_base_to_value(V * value) {
|
||||
return static_cast<IkarusValueData *>(value);
|
||||
}
|
||||
|
||||
template<typename V>
|
||||
struct IkarusValue const * ikarus_value_base_to_value_const(V const * value) {
|
||||
return static_cast<IkarusValue const *>(value);
|
||||
struct IkarusValueData const * ikarus_value_data_base_to_value_data_const(V const * value) {
|
||||
return static_cast<IkarusValueData const *>(value);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue