add src/ikarus subdir and make names unique for objects per scope

Signed-off-by: Folling <mail@folling.io>

src/ikarus/values/entity_property_value.cpp

@@ -0,0 +1,21 @@
+#include "entity_property_value.hpp"
+
+#include <ikarus/errors.hpp>
+
+IkarusEntity const * ikarus_entity_property_value_get_entity(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out) {
+    IKARUS_FAIL_IF_NULL(value, nullptr);
+
+    return value->entity;
+}
+
+IkarusProperty const * ikarus_entity_property_value_get_property(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out) {
+    IKARUS_FAIL_IF_NULL(value, nullptr);
+
+    return value->property;
+}
+
+IkarusValue const * ikarus_entity_property_value_get_value(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out) {
+    IKARUS_FAIL_IF_NULL(value, nullptr);
+
+    return value->value;
+}

src/ikarus/values/entity_property_value.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+struct IkarusEntityPropertyValue {
+    struct IkarusEntity const * entity;
+    struct IkarusProperty const * property;
+    struct IkarusValue const * value;
+};

src/ikarus/values/number_value.cpp

@@ -0,0 +1,65 @@
+#include "ikarus/values/number_value.h"
+
+#include <boost/functional/overloaded_function.hpp>
+
+#include <ikarus/values/number_value.hpp>
+#include <ikarus/values/value_base.hpp>
+
+IkarusNumberValue::IkarusNumberValue():
+    IkarusValue{this} {}
+
+IkarusNumberValue * ikarus_number_value_create() {
+    return new IkarusNumberValue{};
+}
+
+double const * ikarus_number_value_get(IkarusNumberValue * value, size_t idx) {
+    return ikarus_value_base_get(value, idx);
+}
+
+size_t ikarus_number_value_get_size(IkarusNumberValue const * value) {
+    return ikarus_value_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_remove(IkarusNumberValue * value, size_t idx) {
+    return ikarus_value_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_clear(IkarusNumberValue * value) {
+    return ikarus_value_base_clear(value);
+}
+
+bool ikarus_number_value_is_undefined(IkarusNumberValue const * value) {
+    return ikarus_value_base_is_undefined(value);
+}
+
+void ikarus_number_value_set_undefined(IkarusNumberValue * value, bool undefined) {
+    return ikarus_value_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; });
+}
+
+bool ikarus_number_value_is_equal(IkarusNumberValue const * lhs, IkarusNumberValue const * rhs) {
+    return ikarus_value_base_is_equal(lhs, rhs);
+}
+
+IkarusNumberValue * ikarus_number_value_copy(IkarusNumberValue const * value) {
+    return ikarus_value_base_copy(value);
+}
+
+struct IkarusValue * ikarus_number_value_to_value(IkarusNumberValue * value) {
+    return ikarus_value_base_to_value(value);
+}
+
+struct IkarusValue const * ikarus_number_value_to_value_const(IkarusNumberValue const * value) {
+    return ikarus_value_base_to_value_const(value);
+}

src/ikarus/values/number_value.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <boost/container/small_vector.hpp>
+#include <boost/variant2.hpp>
+
+#include <ikarus/values/value.hpp>
+
+struct IkarusNumberValue : IkarusValue {
+public:
+    using DataType = double;
+
+public:
+    explicit IkarusNumberValue();
+
+    IkarusNumberValue(IkarusNumberValue const &) = default;
+    IkarusNumberValue(IkarusNumberValue &&) = default;
+
+    IkarusNumberValue & operator=(IkarusNumberValue const &) = default;
+    IkarusNumberValue & operator=(IkarusNumberValue &&) = default;
+
+    ~IkarusNumberValue() override = default;
+
+public:
+    boost::variant2::variant<boost::variant2::monostate, boost::container::small_vector<DataType, SMALL_VEC_VALUE_SIZE>> data{};
+};

src/ikarus/values/text_value.cpp

@@ -0,0 +1,66 @@
+#include "ikarus/values/text_value.h"
+
+#include <boost/bind/bind.hpp>
+#include <boost/functional/overloaded_function.hpp>
+
+#include <ikarus/values/text_value.hpp>
+#include <ikarus/values/value_base.hpp>
+
+IkarusTextValue::IkarusTextValue():
+    IkarusValue{this} {}
+
+IkarusTextValue * ikarus_text_value_create() {
+    return new IkarusTextValue{};
+}
+
+char const * ikarus_text_value_get(IkarusTextValue * value, size_t idx) {
+    return ikarus_value_base_get(value, idx)->data();
+}
+
+size_t ikarus_text_value_get_size(IkarusTextValue const * value) {
+    return ikarus_value_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_remove(IkarusTextValue * value, size_t idx) {
+    return ikarus_value_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_clear(IkarusTextValue * value) {
+    return ikarus_value_base_clear(value);
+}
+
+bool ikarus_text_value_is_undefined(IkarusTextValue const * value) {
+    return ikarus_value_base_is_undefined(value);
+}
+
+void ikarus_text_value_set_undefined(IkarusTextValue * value, bool undefined) {
+    return ikarus_value_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; });
+}
+
+bool ikarus_text_value_is_equal(IkarusTextValue const * lhs, IkarusTextValue const * rhs) {
+    return ikarus_value_base_is_equal(lhs, rhs);
+}
+
+IkarusTextValue * ikarus_text_value_copy(IkarusTextValue const * value) {
+    return ikarus_value_base_copy(value);
+}
+
+struct IkarusValue * ikarus_text_value_to_value(IkarusTextValue * value) {
+    return ikarus_value_base_to_value(value);
+}
+
+struct IkarusValue const * ikarus_text_value_to_value_const(IkarusTextValue const * value) {
+    return ikarus_value_base_to_value_const(value);
+}

src/ikarus/values/text_value.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <boost/container/small_vector.hpp>
+
+#include <ikarus/values/value.hpp>
+
+struct IkarusTextValue : IkarusValue {
+public:
+    using DataType = std::string;
+
+public:
+    explicit IkarusTextValue();
+
+    IkarusTextValue(IkarusTextValue const &) = default;
+    IkarusTextValue(IkarusTextValue &&) = default;
+
+    IkarusTextValue & operator=(IkarusTextValue const &) = default;
+    IkarusTextValue & operator=(IkarusTextValue &&) = default;
+
+    ~IkarusTextValue() override = default;
+
+public:
+    boost::variant2::variant<boost::variant2::monostate, boost::container::small_vector<DataType, SMALL_VEC_VALUE_SIZE>> data{};
+};

src/ikarus/values/toggle_value.cpp

@@ -0,0 +1,66 @@
+#include "ikarus/values/toggle_value.h"
+
+#include <boost/functional/overloaded_function.hpp>
+#include <boost/range/adaptors.hpp>
+
+#include <ikarus/values/toggle_value.hpp>
+#include <ikarus/values/value_base.hpp>
+
+IkarusToggleValue::IkarusToggleValue():
+    IkarusValue{this} {}
+
+IkarusToggleValue * ikarus_toggle_value_create() {
+    return new IkarusToggleValue{};
+}
+
+bool const * ikarus_toggle_value_get(IkarusToggleValue * value, size_t idx) {
+    return ikarus_value_base_get(value, idx);
+}
+
+size_t ikarus_toggle_value_get_size(IkarusToggleValue const * value) {
+    return ikarus_value_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_remove(IkarusToggleValue * value, size_t idx) {
+    return ikarus_value_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_clear(IkarusToggleValue * value) {
+    return ikarus_value_base_clear(value);
+}
+
+bool ikarus_toggle_value_is_undefined(IkarusToggleValue const * value) {
+    return ikarus_value_base_is_undefined(value);
+}
+
+void ikarus_toggle_value_set_undefined(IkarusToggleValue * value, bool undefined) {
+    return ikarus_value_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 ? "✓" : "✗"; });
+}
+
+bool ikarus_toggle_value_is_equal(IkarusToggleValue const * lhs, IkarusToggleValue const * rhs) {
+    return ikarus_value_base_is_equal(lhs, rhs);
+}
+
+IkarusToggleValue * ikarus_toggle_value_copy(IkarusToggleValue const * value) {
+    return ikarus_value_base_copy(value);
+}
+
+struct IkarusValue * ikarus_toggle_value_to_value(IkarusToggleValue * value) {
+    return ikarus_value_base_to_value(value);
+}
+
+struct IkarusValue const * ikarus_toggle_value_to_value_const(IkarusToggleValue const * value) {
+    return ikarus_value_base_to_value_const(value);
+}

src/ikarus/values/toggle_value.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <boost/container/small_vector.hpp>
+
+#include <ikarus/values/value.hpp>
+
+struct IkarusToggleValue : IkarusValue {
+public:
+    using DataType = bool;
+
+public:
+    explicit IkarusToggleValue();
+
+    IkarusToggleValue(IkarusToggleValue const &) = default;
+    IkarusToggleValue(IkarusToggleValue &&) = default;
+
+    IkarusToggleValue & operator=(IkarusToggleValue const &) = default;
+    IkarusToggleValue & operator=(IkarusToggleValue &&) = default;
+
+    ~IkarusToggleValue() override = default;
+
+public:
+    boost::variant2::variant<boost::variant2::monostate, boost::container::small_vector<DataType, SMALL_VEC_VALUE_SIZE>> data{};
+};

src/ikarus/values/value.cpp

@@ -0,0 +1,138 @@
+#include "ikarus/values/value.h"
+
+#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>
+#include <ikarus/values/number_value.hpp>
+#include <ikarus/values/text_value.hpp>
+#include <ikarus/values/toggle_value.hpp>
+#include <ikarus/values/value.hpp>
+
+IkarusValue::IkarusValue(Data data):
+    data(data) {}
+
+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;
+
+        if (auto const * type_value = obj->if_contains("type"); 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) {
+            return cppbase::err(FromJsonError{});
+        }
+
+        auto create_value = [data]<typename T>() -> cppbase::Result<IkarusValue *, FromJsonError> {
+            T * ret = nullptr;
+
+            if (data->is_null()) {
+                ret = new T{};
+                ret->data = boost::variant2::monostate{};
+            } else {
+                auto res =
+                    boost::json::try_value_to<boost::container::small_vector<typename T::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(*data
+                    );
+
+                if (res.has_error()) {
+                    return cppbase::err(FromJsonError{});
+                }
+
+                ret = new T{};
+                ret->data = std::move(res.value());
+            }
+
+            return cppbase::ok(ret);
+        };
+
+        switch (*type) {
+        case IkarusPropertyType_Toggle: {
+            return create_value.operator()<IkarusToggleValue>();
+        }
+        case IkarusPropertyType_Number: {
+            return create_value.operator()<IkarusNumberValue>();
+        }
+        case IkarusPropertyType_Text: {
+            return create_value.operator()<IkarusTextValue>();
+        }
+        default: {
+            return cppbase::err(FromJsonError{});
+        }
+        }
+    }
+}
+
+boost::json::value IkarusValue::to_json() const {
+    auto type = boost::variant2::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; }
+        },
+        data
+    );
+
+    auto data_json = boost::variant2::visit(
+        []<typename T>(T const * value) -> boost::json::value {
+            return boost::variant2::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); }
+                },
+                value->data
+            );
+        },
+        data
+    );
+
+    return {
+        {"type",      type},
+        {"data", data_json}
+    };
+}
+
+void ikarus_value_visit(
+    IkarusValue * value,
+    void (*toggle_visitor)(IkarusToggleValue *, void *),
+    void (*number_visitor)(IkarusNumberValue *, void *),
+    void (*text_visitor)(IkarusTextValue *, void *),
+    void * data
+) {
+    boost::variant2::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); },
+            [text_visitor, data](IkarusTextValue * text_value) { text_visitor(text_value, data); }
+        },
+        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
+    );
+}

src/ikarus/values/value.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <boost/json.hpp>
+#include <boost/variant2.hpp>
+
+#include <cppbase/result.hpp>
+
+#include <ikarus/errors.hpp>
+#include <ikarus/persistence/project.hpp>
+
+struct IkarusValue {
+public:
+    using Data = boost::variant2::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>;
+    constexpr static auto SMALL_VEC_VALUE_SIZE = 8;
+
+public:
+    explicit IkarusValue(Data data);
+
+    IkarusValue(IkarusValue const &) = default;
+    IkarusValue(IkarusValue &&) noexcept = default;
+
+    IkarusValue & operator=(IkarusValue const &) = default;
+    IkarusValue & operator=(IkarusValue &&) noexcept = default;
+
+    virtual ~IkarusValue() = default;
+
+public:
+    struct FromJsonError {};
+
+    [[nodiscard]] static cppbase::Result<IkarusValue *, FromJsonError> from_json(boost::json::value json);
+    [[nodiscard]] boost::json::value to_json() const;
+
+public:
+    Data data;
+};
+
+template<>
+struct fmt::formatter<IkarusValue::FromJsonError> {
+    template<typename FormatParseContext>
+    constexpr static auto parse(FormatParseContext & ctx) {
+        return ctx.end();
+    }
+
+    constexpr static auto format([[maybe_unused]] IkarusValue::FromJsonError const & error, fmt::format_context & ctx) {
+        return fmt::format_to(ctx.out(), "unable to parse ikarus value JSON");
+    }
+};
+
+template<typename... Args>
+IkarusValue * fetch_value_from_db(IkarusProject * project, IkarusErrorData * error_out, std::string_view query, Args &&... args) {
+    IKARUS_VTRYRV_OR_FAIL(
+        auto const value_str,
+        nullptr,
+        "unable to fetch entity property value from database: {}",
+        IkarusErrorInfo_Database_QueryFailed,
+        project->db->query_one<std::string>(query, std::forward<Args>(args)...)
+    );
+
+    boost::json::error_code ec{};
+    boost::json::value json_value = boost::json::parse(value_str, ec);
+
+    if (ec) {
+        IKARUS_SET_ERROR(fmt::format("invalid json is stored in database: {}", ec.message()), IkarusErrorInfo_Database_InvalidState);
+        return nullptr;
+    }
+
+    IKARUS_VTRYRV_OR_FAIL(
+        auto const ret,
+        nullptr,
+        "unable to fetch entity property value: {}",
+        IkarusErrorInfo_LibIkarus_CannotPerformOperation,
+        IkarusValue::from_json(std::move(json_value))
+    );
+
+    return ret;
+}

src/ikarus/values/value_base.hpp

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <ranges>
+
+#include <boost/container/small_vector.hpp>
+
+#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);
+        data != nullptr) {
+        return &(*data)[idx];
+    }
+
+    return nullptr;
+}
+
+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);
+        data != nullptr) {
+        return data->size();
+    }
+
+    return 0;
+}
+
+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);
+        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);
+        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);
+        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);
+        data != nullptr) {
+        data->clear();
+    }
+}
+
+template<typename V>
+bool ikarus_value_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) {
+    if (undefined) {
+        value->data = boost::variant2::monostate{};
+    } else {
+        value->data = boost::container::small_vector<typename V::DataType, IkarusValue::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) {
+    return boost::variant2::visit(
+        cppbase::overloaded{
+            [](boost::variant2::monostate const &) -> char const * { return nullptr; },
+            [&transformer](auto const & data) -> char const * {
+                auto buffer = fmt::memory_buffer{};
+
+                fmt::format_to(
+                    std::back_inserter(buffer),
+                    "{}",
+                    fmt::join(data | std::views::transform(std::forward<F>(transformer)), ", ")
+                );
+
+                return buffer.data();
+            }
+        },
+        value->data
+    );
+}
+
+template<typename V>
+bool ikarus_value_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) {
+    return new V{*value};
+}
+
+template<typename V>
+struct IkarusValue * ikarus_value_base_to_value(V * value) {
+    return static_cast<IkarusValue *>(value);
+}
+
+template<typename V>
+struct IkarusValue const * ikarus_value_base_to_value_const(V const * value) {
+    return static_cast<IkarusValue const *>(value);
+}