From 7be1675180d10afd106c3ec245ebef51cf8c61b1 Mon Sep 17 00:00:00 2001 From: folling Date: Mon, 11 Dec 2023 16:16:34 +0100 Subject: [PATCH] implement IkarusPropertySource and switch to cppbase::overloaded Signed-off-by: Folling --- src/objects/blueprint.hpp | 2 +- src/objects/entity.hpp | 2 +- src/objects/properties/property_source.cpp | 46 ++++++++++++++++++++++ src/objects/properties/property_source.hpp | 16 +++----- src/objects/properties/toggle_property.hpp | 2 +- src/values/number_value.hpp | 6 +-- src/values/text_value.hpp | 6 +-- src/values/toggle_value.hpp | 6 +-- src/values/value.cpp | 21 +++++----- src/values/value_base.hpp | 33 ++++++++-------- 10 files changed, 90 insertions(+), 50 deletions(-) diff --git a/src/objects/blueprint.hpp b/src/objects/blueprint.hpp index 41042ba..6fa6281 100644 --- a/src/objects/blueprint.hpp +++ b/src/objects/blueprint.hpp @@ -2,7 +2,7 @@ #include -struct IkarusBlueprint final : IkarusObject { +struct IkarusBlueprint : IkarusObject { IkarusBlueprint(struct IkarusProject * project, IkarusId id); IkarusBlueprint(IkarusBlueprint const&) = default; diff --git a/src/objects/entity.hpp b/src/objects/entity.hpp index fb78e39..f6d4f90 100644 --- a/src/objects/entity.hpp +++ b/src/objects/entity.hpp @@ -2,7 +2,7 @@ #include -struct IkarusEntity final : IkarusObject { +struct IkarusEntity : IkarusObject { inline IkarusEntity(struct IkarusProject * project, IkarusId id): IkarusObject{project, id} {} diff --git a/src/objects/properties/property_source.cpp b/src/objects/properties/property_source.cpp index e69de29..364ca84 100644 --- a/src/objects/properties/property_source.cpp +++ b/src/objects/properties/property_source.cpp @@ -0,0 +1,46 @@ +#include "property_source.hpp" + +#include + +#include + +IkarusPropertySource::IkarusPropertySource(Data data): + data{data} {} + +IkarusPropertySource * ikarus_property_source_create_blueprint(IkarusBlueprint * blueprint) { + return new IkarusPropertySource{blueprint}; +} + +IkarusPropertySource * ikarus_property_source_create_entity(IkarusEntity * entity) { + return new IkarusPropertySource{entity}; +} + +void ikarus_property_source_visit( + struct IkarusPropertySource * property_source, + void (*blueprint_visitor)(struct IkarusBlueprint *, void *), + void (*entity_visitor)(struct IkarusEntity *, void *), + void * user_data +) { + boost::variant2::visit( + boost::make_overloaded_function( + [blueprint_visitor, user_data](IkarusBlueprint * blueprint) { blueprint_visitor(blueprint, user_data); }, + [entity_visitor, user_data](IkarusEntity * entity) { entity_visitor(entity, user_data); } + ), + property_source->data + ); +} + +void ikarus_property_source_visit_const( + struct IkarusPropertySource const * property_source, + void (*blueprint_visitor)(struct IkarusBlueprint const *, void *), + void (*entity_visitor)(struct IkarusEntity const *, void *), + void * user_data +) { + boost::variant2::visit( + boost::make_overloaded_function( + [blueprint_visitor, user_data](IkarusBlueprint const * blueprint) { blueprint_visitor(blueprint, user_data); }, + [entity_visitor, user_data](IkarusEntity const * entity) { entity_visitor(entity, user_data); } + ), + property_source->data + ); +} diff --git a/src/objects/properties/property_source.hpp b/src/objects/properties/property_source.hpp index 8da517a..0fda4ed 100644 --- a/src/objects/properties/property_source.hpp +++ b/src/objects/properties/property_source.hpp @@ -1,16 +1,15 @@ #pragma once -#include +#include #include struct IkarusPropertySource { public: - using Data = std::variant; + using Data = boost::variant2::variant; public: - inline explicit IkarusPropertySource(Data data): - _data{data} {} + explicit IkarusPropertySource(Data data); IkarusPropertySource(IkarusPropertySource const&) = default; IkarusPropertySource(IkarusPropertySource&&) = default; @@ -18,13 +17,8 @@ public: IkarusPropertySource& operator=(IkarusPropertySource const&) = default; IkarusPropertySource& operator=(IkarusPropertySource&&) = default; - ~IkarusPropertySource() = default; + virtual ~IkarusPropertySource() = default; public: - [[nodiscard]] inline Data const& get_data() const { - return _data; - } - -private: - std::variant _data; + Data data; }; diff --git a/src/objects/properties/toggle_property.hpp b/src/objects/properties/toggle_property.hpp index 2ca2520..92bbbc4 100644 --- a/src/objects/properties/toggle_property.hpp +++ b/src/objects/properties/toggle_property.hpp @@ -2,7 +2,7 @@ #include -struct IkarusToggleProperty final : IkarusProperty { +struct IkarusToggleProperty : IkarusProperty { public: IkarusToggleProperty(struct IkarusProject * project, IkarusId id); }; diff --git a/src/values/number_value.hpp b/src/values/number_value.hpp index 16f99c7..1421ca3 100644 --- a/src/values/number_value.hpp +++ b/src/values/number_value.hpp @@ -5,9 +5,9 @@ #include -struct IkarusNumberValue final : IkarusValue { +struct IkarusNumberValue : IkarusValue { public: - using data_type = double; + using DataType = double; public: explicit IkarusNumberValue(); @@ -21,6 +21,6 @@ public: ~IkarusNumberValue() override = default; public: - boost::variant2::variant> data{ + boost::variant2::variant> data{ }; }; diff --git a/src/values/text_value.hpp b/src/values/text_value.hpp index 1ff74ac..117e175 100644 --- a/src/values/text_value.hpp +++ b/src/values/text_value.hpp @@ -4,9 +4,9 @@ #include -struct IkarusTextValue final : IkarusValue { +struct IkarusTextValue : IkarusValue { public: - using data_type = std::string; + using DataType = std::string; public: explicit IkarusTextValue(); @@ -20,6 +20,6 @@ public: ~IkarusTextValue() override = default; public: - boost::variant2::variant> data{ + boost::variant2::variant> data{ }; }; diff --git a/src/values/toggle_value.hpp b/src/values/toggle_value.hpp index 20c579c..7e2240f 100644 --- a/src/values/toggle_value.hpp +++ b/src/values/toggle_value.hpp @@ -4,9 +4,9 @@ #include -struct IkarusToggleValue final : IkarusValue { +struct IkarusToggleValue : IkarusValue { public: - using data_type = bool; + using DataType = bool; public: explicit IkarusToggleValue(); @@ -20,6 +20,6 @@ public: ~IkarusToggleValue() override = default; public: - boost::variant2::variant> data{ + boost::variant2::variant> data{ }; }; diff --git a/src/values/value.cpp b/src/values/value.cpp index 81cdaa9..2cffcaa 100644 --- a/src/values/value.cpp +++ b/src/values/value.cpp @@ -3,9 +3,10 @@ #include #include -#include // required for header-only inclusion +#include "cppbase/templates.hpp" + #include #include @@ -43,7 +44,7 @@ cppbase::Result IkarusValue::from_jso ret->data = boost::variant2::monostate{}; } else { auto res = boost::json::try_value_to< - boost::container::small_vector>(*data); + boost::container::small_vector>(*data); if (res.has_error()) { return cppbase::err(FromJsonError{}); @@ -75,21 +76,21 @@ cppbase::Result IkarusValue::from_jso boost::json::value IkarusValue::to_json() const { auto type = boost::variant2::visit( - boost::make_overloaded_function( + 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( [](T const * value) -> boost::json::value { return boost::variant2::visit( - boost::make_overloaded_function( + 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 ); }, @@ -110,11 +111,11 @@ void ikarus_value_visit( void * data ) { boost::variant2::visit( - boost::make_overloaded_function( + 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 ); } @@ -127,11 +128,11 @@ void ikarus_value_visit_const( void * data ) { boost::variant2::visit( - boost::make_overloaded_function( + 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 ); } diff --git a/src/values/value_base.hpp b/src/values/value_base.hpp index 416be34..46cf457 100644 --- a/src/values/value_base.hpp +++ b/src/values/value_base.hpp @@ -1,16 +1,15 @@ #pragma once -#include #include -#include +#include + #include -#include template -typename V::data_type const * ikarus_value_base_get(V * value, size_t idx) { +typename V::DataType const * ikarus_value_base_get(V * value, size_t idx) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -23,7 +22,7 @@ typename V::data_type const * ikarus_value_base_get(V * value, size_t idx) { template size_t ikarus_value_base_get_size(V const * value) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -34,9 +33,9 @@ size_t ikarus_value_base_get_size(V const * value) { } template -void ikarus_value_base_set(V * value, size_t idx, typename V::data_type new_data) { +void ikarus_value_base_set(V * value, size_t idx, typename V::DataType new_data) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -47,7 +46,7 @@ void ikarus_value_base_set(V * value, size_t idx, typename V::data_type new_data template void ikarus_value_base_remove(V * value, size_t idx) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -56,9 +55,9 @@ void ikarus_value_base_remove(V * value, size_t idx) { } template -void ikarus_value_base_insert(V * value, size_t idx, typename V::data_type new_data) { +void ikarus_value_base_insert(V * value, size_t idx, typename V::DataType new_data) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -69,7 +68,7 @@ void ikarus_value_base_insert(V * value, size_t idx, typename V::data_type new_d template void ikarus_value_base_clear(V * value) { if (auto * data = - boost::variant2::get_if>( + boost::variant2::get_if>( &value->data ); data != nullptr) { @@ -87,16 +86,16 @@ void ikarus_value_base_set_undefined(V * value, bool undefined) { if (undefined) { value->data = boost::variant2::monostate{}; } else { - value->data = boost::container::small_vector{}; + value->data = boost::container::small_vector{}; } } -template F> +template F> char const * ikarus_value_base_to_string(V const * value, F transformer) { return boost::variant2::visit( - boost::make_overloaded_function( + cppbase::overloaded { [](boost::variant2::monostate const&) -> char const * { return nullptr; }, - [&transformer](boost::container::small_vector const& data + [&transformer](auto const& data ) -> char const * { auto buffer = fmt::memory_buffer{}; @@ -108,7 +107,7 @@ char const * ikarus_value_base_to_string(V const * value, F transformer) { return buffer.data(); } - ), + }, value->data ); }