Ikarus/libikarus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

implement remaining logic

Browse source 
Signed-off-by: Folling <mail@folling.io>
This commit is contained in:
Folling 2024-01-03 17:14:26 +01:00 • committed by Folling
parent e1bf97704a
commit 1ce811d566
No known key found for this signature in database
41 changed files with 1393 additions and 408 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.clang-tidy
View file

@ -1,7 +1,7 @@
Checks: >- Checks: >-
-*, -*,
bugprone-*, -bugprone-lambda-function-name, bugprone-*, -bugprone-lambda-function-name,
cppcoreguidelines-*, -cppcoreguidelines-owning-memory, -cppcoreguidelines-non-private-member-variables-in-classes, cppcoreguidelines-*, -cppcoreguidelines-macro-usage, -cppcoreguidelines-owning-memory, -cppcoreguidelines-non-private-member-variables-in-classes,
clang-analyzer-*, clang-analyzer-*,
google-*, -google-readability-todo, google-*, -google-readability-todo,
modernize-*, -modernize-use-trailing-return-type, modernize-*, -modernize-use-trailing-return-type,
@ -9,9 +9,9 @@ Checks: >-
portability-*, portability-*,
readability-*, -readability-redundant-access-specifiers readability-*, -readability-redundant-access-specifiers
CheckOptions: CheckOptions:
readability-identifier-length.IgnoredParameterNames: '^(db|rc|id)$' readability-identifier-length.IgnoredParameterNames: '^(db|rc|id|ec)$'
readability-identifier-length.IgnoredLoopCounterNames: '^[ij]$' readability-identifier-length.IgnoredLoopCounterNames: '^[ij]$'
readability-identifier-length.IgnoredVariableNames: '^(db|rc|id)$' readability-identifier-length.IgnoredVariableNames: '^(db|rc|id|ec)$'
cppcoreguidelines-avoid-do-while.IgnoreMacros: Yes cppcoreguidelines-avoid-do-while.IgnoreMacros: Yes
HeaderFileExtensions: HeaderFileExtensions:
- h - h

2
CMakeLists.txt
View file

@ -14,7 +14,7 @@ add_subdirectory(vendor)
add_subdirectory(include) add_subdirectory(include)
add_subdirectory(src) add_subdirectory(src)
find_package(Boost REQUIRED) find_package(Boost COMPONENTS system filesystem REQUIRED)
add_library( add_library(
libikarus SHARED libikarus SHARED

87
include/ikarus/errors.h
View file

@ -4,6 +4,7 @@
/// \author Folling <folling@ikarus.world> /// \author Folling <folling@ikarus.world>
#include <ikarus/macros.h> #include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
/// \addtogroup errors Errors /// \addtogroup errors Errors
/// \brief Error handling within libikarus /// \brief Error handling within libikarus
@ -24,94 +25,81 @@ IKARUS_BEGIN_HEADER
enum IkarusErrorInfo { enum IkarusErrorInfo {
/// \brief No error occurred. /// \brief No error occurred.
IkarusErrorInfo_None = 0x0, IkarusErrorInfo_None = 0x0,
/// \brief The error was caused by the client.
IkarusErrorInfo_Client = 0x10100000,
/// \brief The error was caused by a dependency (e.g. boost) of libikarus.
IkarusErrorInfo_Dependency = 0x10200000,
/// \brief The error was caused by the filesystem.
IkarusErrorInfo_Filesystem = 0x10300000,
/// \brief The error was caused by the database.
IkarusErrorInfo_Database = 0x10400000,
/// \brief The error was caused by the underlying OS.
IkarusErrorInfo_OS = 0x10500000,
/// \brief The error was caused by libikarus itself.
IkarusErrorInfo_LibIkarus = 0x10600000,
/// \brief The client misused the API. /// \brief The client misused the API.
/// Example: Accessing a resource that does not exist. /// Example: Accessing a resource that does not exist.
IkarusErrorInfo_Client_Misuse = 0x10100001, IkarusErrorInfo_Client_Misuse = 0x01000001,
/// \brief The client provided a null value for a parameter that must not be null. /// \brief The client provided a null value for a parameter that must not be null.
/// Example: Passing null for `ikarus_project_get_name` /// Example: Passing null for `ikarus_project_get_name`
IkarusErrorInfo_Client_InvalidNull = 0x10100002, IkarusErrorInfo_Client_InvalidNull = 0x01000002,
/// \brief The client provided an index that was out of bounds for some array. /// \brief The client provided an index that was out of bounds for some array.
/// Example: Passing the index 3 for an `IkarusToggleValue` with size 3. /// Example: Passing the index 3 for an `IkarusToggleValue` with size 3.
IkarusErrorInfo_Client_IndexOutOfBounds = 0x10100003, IkarusErrorInfo_Client_IndexOutOfBounds = 0x01000003,
/// \brief The client provided a numeric value that was out of bounds /// \brief The client provided a numeric value that was out of bounds
/// Example: Passing the value 2^32 to an i32 (might be passed as a string). /// Example: Passing the value 2^32 to an i32 (might be passed as a string).
IkarusErrorInfo_Client_ValueOutOfBounds = 0x10100004, IkarusErrorInfo_Client_ValueOutOfBounds = 0x01000004,
/// \brief The client provided invalid input that doesn't fit in any of the other categories. /// \brief The client provided invalid input that doesn't fit in any of the other categories.
/// Example: Passing an empty/blank string for a string that must be non-empty/-blank. /// Example: Passing an empty/blank string for a string that must be non-empty/-blank.
IkarusErrorInfo_Client_InvalidInput = 0x10100005, IkarusErrorInfo_Client_InvalidInput = 0x01000005,
/// \brief The client provided valid data in an invalid format. /// \brief The client provided valid data in an invalid format.
/// Example: Passing a malformed JSON string. /// Example: Passing a malformed JSON string.
IkarusErrorInfo_Client_InvalidFormat = 0x10100006, IkarusErrorInfo_Client_InvalidFormat = 0x01000006,
/// \brief The client violated a constraint. /// \brief The client violated a constraint.
/// \details This error is most likely caused by endusers. /// \details This error is most likely caused by endusers.
/// Example: A user tries to set the age of a character to an value outside of their specified range. /// Example: A user tries to set the age of a character to an value outside of their specified range.
IkarusErrorInfo_Client_ConstraintViolated = 0x10100007, IkarusErrorInfo_Client_ConstraintViolated = 0x10000007,
// 0x02 reserved for dependency errors
/// \brief A file was not found.
IkarusErrorInfo_Filesystem_NotFound = 0x10300001,
/// \brief A file or directory already exists. /// \brief A file or directory already exists.
IkarusErrorInfo_Filesystem_AlreadyExists = 0x10300002, IkarusErrorInfo_Filesystem_AccessIssue = 0x03000001,
/// \brief A file was not found.
IkarusErrorInfo_Filesystem_NotFound = 0x03000002,
/// \brief A file or directory already exists.
IkarusErrorInfo_Filesystem_AlreadyExists = 0x03000003,
/// \brief Missing permissions to access a file or directory. /// \brief Missing permissions to access a file or directory.
IkarusErrorInfo_Filesystem_MissingPermissions = 0x10300003, IkarusErrorInfo_Filesystem_MissingPermissions = 0x03000004,
/// \brief Insufficient space to perform an operation. /// \brief Insufficient space to perform an operation.
IkarusErrorInfo_Filesystem_InsufficientSpace = 0x10300004, IkarusErrorInfo_Filesystem_InsufficientSpace = 0x03000005,
/// \brief A path is invalid. /// \brief A path is invalid.
IkarusErrorInfo_Filesystem_InvalidPath = 0x10300005, IkarusErrorInfo_Filesystem_InvalidPath = 0x03000006,
/// \brief A database connection failed. /// \brief A database connection failed.
IkarusErrorInfo_Database_ConnectionFailed = 0x10400001, IkarusErrorInfo_Database_ConnectionFailed = 0x04000001,
/// \brief A database query failed. /// \brief A database query failed.
IkarusErrorInfo_Database_QueryFailed = 0x10400002, IkarusErrorInfo_Database_QueryFailed = 0x04000002,
/// \brief A database migration failed. /// \brief A database migration failed.
IkarusErrorInfo_Database_MigrationFailed = 0x10400003, IkarusErrorInfo_Database_MigrationFailed = 0x04000003,
/// \brief A database is in an invalid state. This indicates a corrupt project. /// \brief A database is in an invalid state. This indicates a corrupt project.
/// Example: An entity is linked to a non-existant blueprint. /// Example: An entity is linked to a non-existant blueprint.
IkarusErrorInfo_Database_InvalidState = 0x10400004, IkarusErrorInfo_Database_InvalidState = 0x04000004,
/// \brief A system call failed. /// \brief A system call failed.
IkarusErrorInfo_OS_SystemCallFailed = 0x10500001, IkarusErrorInfo_OS_SystemCallFailed = 0x05000001,
/// \brief A system call returned an invalid value. /// \brief A system call returned an invalid value.
IkarusErrorInfo_OS_InvalidReturnValue = 0x10500002, IkarusErrorInfo_OS_InvalidReturnValue = 0x05000002,
/// \brief An OOM error occurred. /// \brief An OOM error occurred.
IkarusErrorInfo_OS_InsufficientMemory = 0x10500003, IkarusErrorInfo_OS_InsufficientMemory = 0x05000003,
/// \brief A datapoint within ikarus is invalid for the current state of the system. /// \brief A datapoint within ikarus is invalid for the current state of the system.
/// \details This differs from IkarusErrorInfo_Database_InvalidState in that the latter implies the database itself holds invalid state,
/// whereas the former may imply that the state is ephemeral, e.g. data within a function.
/// Example: The name of an object is found to be invalid UTF8. /// Example: The name of an object is found to be invalid UTF8.
IkarusErrorInfo_LibIkarus_InvalidState = 0x20030001, IkarusErrorInfo_LibIkarus_InvalidState = 0x06000001,
/// \brief libikarus is unable to perform a certain operation that should succeed.
IkarusErrorInfo_LibIkarus_CannotPerformOperation = 0x06000002,
/// \brief libikarus is unable to perform a certain operation within a given timeframe. /// \brief libikarus is unable to perform a certain operation within a given timeframe.
/// Example: A query takes longer than the timeout. /// Example: A query takes longer than the timeout.
IkarusErrorInfo_LibIkarus_Timeout = 0x20030003, IkarusErrorInfo_LibIkarus_Timeout = 0x06000003,
}; };
/// \brief The data limits for an error. size_t const IKARUS_ERROR_DATA_MAX_MESSAGE_LIMIT = 128;
enum IkarusErrorDataLimit {
/// \brief The maximum number of error infos that can be stored in an error.
IkarusErrorDataLimit_MaxErrorInfos = 8,
/// \brief The maximum length of an error message.
IkarusErrorDataLimit_MaxMessageLength = 128,
};
/// \brief The data stored for an error /// \brief The data stored for an error
struct IkarusErrorData { struct IkarusErrorData {
/// \brief The scope of the error. /// \brief The error type
/// \details This array may at most hold #IkarusErrorDataLimit_MaxErrorInfos elements. IkarusErrorInfo info;
/// The first occurrence of #IkarusErrorInfo_None signifies the end of the array. If this happens at idx x== 0, no error occurred.
IkarusErrorInfo infos[IkarusErrorDataLimit_MaxErrorInfos];
char message[IkarusErrorDataLimit_MaxMessageLength]; char message[IKARUS_ERROR_DATA_MAX_MESSAGE_LIMIT];
}; };
/// \brief Gets the name of an error info. /// \brief Gets the name of an error info.
@ -128,11 +116,6 @@ IKA_API bool ikarus_error_data_is_success(IkarusErrorData const * data);
/// \param data The error data to check. /// \param data The error data to check.
/// \return True if the error data is an error, false otherwise. /// \return True if the error data is an error, false otherwise.
IKA_API bool ikarus_error_data_is_error(IkarusErrorData const * data); IKA_API bool ikarus_error_data_is_error(IkarusErrorData const * data);
/// \brief Formats the error data in a reasonable but unspecified way.
/// \param data The error data to format.
/// \return The formatted error data.
/// \remark Ownership of the returned pointer is passed to the user and must be freed at their leisure using ikarus_free.
IKA_API char const * ikarus_error_data_pretty_format(IkarusErrorData const * data);
IKARUS_END_HEADER IKARUS_END_HEADER

51
include/ikarus/objects/entity.h
View file

@ -89,6 +89,30 @@ IKA_API void ikarus_entity_link_to_blueprint(IkarusEntity * entity, struct Ikaru
/// \remark No-op if the entity is not linked to the blueprint. /// \remark No-op if the entity is not linked to the blueprint.
IKA_API void ikarus_entity_unlink_from_blueprint(IkarusEntity * entity, struct IkarusBlueprint * blueprint, IkarusErrorData * error_out); IKA_API void ikarus_entity_unlink_from_blueprint(IkarusEntity * entity, struct IkarusBlueprint * blueprint, IkarusErrorData * error_out);
/// \brief Gets the blueprints an entity is linked to.
/// \param entity The entity to get the blueprints of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param blueprints_out The buffer to write the blueprints to.
/// \pre \li Must not be null.
/// \param blueprints_out_size The size of the buffer.
/// \param error_out \see errors.h
/// \see ikarus_entity_get_linked_blueprint_count
IKA_API void ikarus_entity_get_linked_blueprints(
IkarusEntity const * entity,
struct IkarusBlueprint ** blueprints_out,
size_t blueprints_out_size,
IkarusErrorData * error_out
);
/// \brief Gets the number of blueprints an entity is linked to.
/// \param entity The entity to get the number of blueprints of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The number of blueprints or undefined if an error occurs.
IKA_API size_t ikarus_entity_get_linked_blueprint_count(IkarusEntity const * entity, IkarusErrorData * error_out);
/// \brief Checks if an entity has a specific property. /// \brief Checks if an entity has a specific property.
/// \param entity The entity to check. /// \param entity The entity to check.
/// \pre \li Must not be null. /// \pre \li Must not be null.
@ -97,17 +121,9 @@ IKA_API void ikarus_entity_unlink_from_blueprint(IkarusEntity * entity, struct I
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return True if the entity has the property, false otherwise. /// \return False if an error occurs or the entity does not have the property, true otherwise.
IKA_API bool ikarus_entity_has_property(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out); IKA_API bool ikarus_entity_has_property(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Gets the number of properties of an entity.
/// \param entity The entity to get the number of properties of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The number of properties or undefined if an error occurs.
IKA_API size_t ikarus_entity_get_property_count(IkarusEntity const * entity, IkarusErrorData * error_out);
/// \brief Gets the properties of an entity. /// \brief Gets the properties of an entity.
/// \param entity The entity to get the properties of. /// \param entity The entity to get the properties of.
/// \pre \li Must not be null. /// \pre \li Must not be null.
@ -116,6 +132,7 @@ IKA_API size_t ikarus_entity_get_property_count(IkarusEntity const * entity, Ika
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \param properties_out_size The size of the buffer. /// \param properties_out_size The size of the buffer.
/// \see ikarus_entity_get_property_count
IKA_API void ikarus_entity_get_properties( IKA_API void ikarus_entity_get_properties(
IkarusEntity const * entity, IkarusEntity const * entity,
struct IkarusProperty ** properties_out, struct IkarusProperty ** properties_out,
@ -123,9 +140,16 @@ IKA_API void ikarus_entity_get_properties(
IkarusErrorData * error_out IkarusErrorData * error_out
); );
/// \brief Gets the number of properties of an entity.
/// \param entity The entity to get the number of properties of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The number of properties or undefined if an error occurs.
IKA_API size_t ikarus_entity_get_property_count(IkarusEntity const * entity, IkarusErrorData * error_out);
/// \brief Gets the value of a property of an entity. /// \brief Gets the value of a property of an entity.
/// \details If the entity has never set the value of the property, the default value is returned (which may be /// \details If the entity has never set the value of the property, the default value is returned (which may be undefined).
/// undefined).
/// \param entity The entity to get the value of. /// \param entity The entity to get the value of.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
@ -134,9 +158,8 @@ IKA_API void ikarus_entity_get_properties(
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The value of the property or null if the entity does not have the property or an error occurs. /// \return The value of the property or null if the entity does not have the property or an error occurs.
/// \remark Must be freed using /// \remark Must be freed using #ikarus_free.
/// #ikarus_free. IKA_API struct IkarusEntityPropertyValue *
IKA_API struct IkarusEntityValue *
ikarus_entity_get_value(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out); ikarus_entity_get_value(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Sets the value of a property of an entity. /// \brief Sets the value of a property of an entity.

16
include/ikarus/objects/object.h
View file

@ -19,6 +19,13 @@ IKARUS_BEGIN_HEADER
/// \brief A generic object. Wraps all types of objects, including folders. /// \brief A generic object. Wraps all types of objects, including folders.
struct IkarusObject; struct IkarusObject;
/// \brief Fetches the project of an object.
/// \param object The object to fetch the project from.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The project of the object or null if an error occurs.
IKA_API struct IkarusProject * ikarus_object_get_project(IkarusObject const * object, IkarusErrorData * error_out);
/// \brief Compares two objects for equality. /// \brief Compares two objects for equality.
/// \details This neither compares the pointers nor does a deep copy. Instead it figures out if the objects _are_ the /// \details This neither compares the pointers nor does a deep copy. Instead it figures out if the objects _are_ the
/// same object. /// same object.
@ -35,9 +42,6 @@ IKA_API bool ikarus_object_is_equal(IkarusObject const * lhs, IkarusObject const
/// \param blueprint_visitor The function to call if the object is a blueprint. Skipped if null. /// \param blueprint_visitor The function to call if the object is a blueprint. Skipped if null.
/// \param property_visitor The function to call if the object is a property. Skipped if null. /// \param property_visitor The function to call if the object is a property. Skipped if null.
/// \param entity_visitor The function to call if the object is an entity. Skipped if null. /// \param entity_visitor The function to call if the object is an entity. Skipped if null.
/// \param blueprint_folder_visitor The function to call if the object is a blueprint folder. Skipped if null.
/// \param property_folder_visitor The function to call if the object is a property folder. Skipped if null.
/// \param entity_folder_visitor The function to call if the object is an entity folder. Skipped if null.
/// \param data The data passed to the visitor functions. /// \param data The data passed to the visitor functions.
/// \param error_out \see errors.h /// \param error_out \see errors.h
IKA_API void ikarus_object_visit( IKA_API void ikarus_object_visit(
@ -45,9 +49,6 @@ IKA_API void ikarus_object_visit(
void (*blueprint_visitor)(struct IkarusBlueprint *, void *), void (*blueprint_visitor)(struct IkarusBlueprint *, void *),
void (*property_visitor)(struct IkarusProperty *, void *), void (*property_visitor)(struct IkarusProperty *, void *),
void (*entity_visitor)(struct IkarusEntity *, void *), void (*entity_visitor)(struct IkarusEntity *, void *),
void (*blueprint_folder_visitor)(struct IkarusBlueprintFolder *, void *),
void (*property_folder_visitor)(struct IkarusPropertyFolder *, void *),
void (*entity_folder_visitor)(struct IkarusEntityFolder *, void *),
void * data, void * data,
IkarusErrorData * error_out IkarusErrorData * error_out
); );
@ -58,9 +59,6 @@ IKA_API void ikarus_object_visit_const(
void (*blueprint_visitor)(struct IkarusBlueprint const *, void *), void (*blueprint_visitor)(struct IkarusBlueprint const *, void *),
void (*property_visitor)(struct IkarusProperty const *, void *), void (*property_visitor)(struct IkarusProperty const *, void *),
void (*entity_visitor)(struct IkarusEntity const *, void *), void (*entity_visitor)(struct IkarusEntity const *, void *),
void (*blueprint_folder_visitor)(struct IkarusBlueprintFolder const *, void *),
void (*property_folder_visitor)(struct IkarusPropertyFolder const *, void *),
void (*entity_folder_visitor)(struct IkarusEntityFolder const *, void *),
void * data, void * data,
IkarusErrorData * error_out IkarusErrorData * error_out
); );

3
include/ikarus/objects/object_type.h
View file

@ -25,10 +25,9 @@ enum IkarusObjectType {
/// \brief Converts an IkarusObjectType to a string. /// \brief Converts an IkarusObjectType to a string.
/// \param type The type to convert. /// \param type The type to convert.
/// \param error_out \see errors.h
/// \return The string representation of the type. /// \return The string representation of the type.
/// \remark The returned string must not be freed. /// \remark The returned string must not be freed.
char const * ikarus_object_type_to_string(IkarusObjectType type, IkarusErrorData * error_out); char const * ikarus_object_type_to_string(IkarusObjectType type);
IKARUS_END_HEADER IKARUS_END_HEADER

4
include/ikarus/objects/properties/number_property.h
View file

@ -46,7 +46,7 @@ ikarus_number_property_get_default_value(struct IkarusNumberProperty * property,
/// \param property The number property. /// \param property The number property.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param default_value The default value. /// \param new_default_value The default value.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must be a valid value for the property. /// \pre \li Must be a valid value for the property.
/// \param error_out \see errors.h /// \param error_out \see errors.h
@ -54,7 +54,7 @@ ikarus_number_property_get_default_value(struct IkarusNumberProperty * property,
/// default values and other settings. /// default values and other settings.
IKA_API void ikarus_number_property_set_default_value( IKA_API void ikarus_number_property_set_default_value(
struct IkarusNumberProperty * property, struct IkarusNumberProperty * property,
struct IkarusNumberValue * default_value, struct IkarusNumberValue * new_default_value,
IkarusErrorData * error_out IkarusErrorData * error_out
); );

2
include/ikarus/objects/properties/property.h
View file

@ -89,7 +89,7 @@ IKA_API struct IkarusPropertySource const * ikarus_property_get_source(IkarusPro
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The default value of the property or null if an error occurs. /// \return The default value of the property or null if an error occurs.
/// \remark Must be freed using #ikarus_free. /// \remark Must be freed using #ikarus_free.
IKA_API struct IkarusValue const * ikarus_property_get_default_value(IkarusProperty const * property, IkarusErrorData * error_out); IKA_API struct IkarusValue * ikarus_property_get_default_value(IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Visits a property. Calling the appropriate function for the property's type. /// \brief Visits a property. Calling the appropriate function for the property's type.
/// \param property The property to visit. /// \param property The property to visit.

6
include/ikarus/objects/properties/property_type.h
View file

@ -15,11 +15,11 @@ IKARUS_BEGIN_HEADER
/// available. /// available.
enum IkarusPropertyType { enum IkarusPropertyType {
/// \brief A true/false boolean-esque value. /// \brief A true/false boolean-esque value.
IkarusPropertyType_Toggle, IkarusPropertyType_Toggle = 0x10000000,
/// \brief A numeric value, limited to IEEE 80 bit floating point numbers. /// \brief A numeric value, limited to IEEE 80 bit floating point numbers.
IkarusPropertyType_Number, IkarusPropertyType_Number = 0x20000000,
/// \brief An arbitrary UTF-8 textual value. /// \brief An arbitrary UTF-8 textual value.
IkarusPropertyType_Text, IkarusPropertyType_Text = 0x30000000,
}; };
IKARUS_END_HEADER IKARUS_END_HEADER

4
include/ikarus/objects/properties/text_property.h
View file

@ -45,7 +45,7 @@ IKA_API struct IkarusTextValue * ikarus_text_property_get_default_value(struct I
/// \param property The text property. /// \param property The text property.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param default_value The default value. /// \param new_default_value The default value.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must be a valid value for the property. /// \pre \li Must be a valid value for the property.
/// \param error_out \see errors.h /// \param error_out \see errors.h
@ -53,7 +53,7 @@ IKA_API struct IkarusTextValue * ikarus_text_property_get_default_value(struct I
/// default values and other settings. /// default values and other settings.
IKA_API void ikarus_text_property_set_default_value( IKA_API void ikarus_text_property_set_default_value(
struct IkarusTextProperty * property, struct IkarusTextProperty * property,
struct IkarusTextValue * default_value, struct IkarusTextValue * new_default_value,
IkarusErrorData * error_out IkarusErrorData * error_out
); );

4
include/ikarus/objects/properties/toggle_property.h
View file

@ -46,7 +46,7 @@ ikarus_toggle_property_get_default_value(struct IkarusToggleProperty * property,
/// \param property The toggle property. /// \param property The toggle property.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param default_value The default value. /// \param new_default_value The default value.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must be a valid value for the property. /// \pre \li Must be a valid value for the property.
/// \param error_out \see errors.h /// \param error_out \see errors.h
@ -54,7 +54,7 @@ ikarus_toggle_property_get_default_value(struct IkarusToggleProperty * property,
/// default values and other settings. /// default values and other settings.
IKA_API void ikarus_toggle_property_set_default_value( IKA_API void ikarus_toggle_property_set_default_value(
struct IkarusToggleProperty * property, struct IkarusToggleProperty * property,
struct IkarusToggleValue * default_value, struct IkarusToggleValue * new_default_value,
IkarusErrorData * error_out IkarusErrorData * error_out
); );

68
include/ikarus/persistence/project.h
View file

@ -51,39 +51,13 @@ IKA_API IkarusProject * ikarus_project_create_in_memory(char const * name, Ikaru
/// ikarus_project_delete /// ikarus_project_delete
IKA_API IkarusProject * ikarus_project_open(char const * path, IkarusErrorData * error_out); IKA_API IkarusProject * ikarus_project_open(char const * path, IkarusErrorData * error_out);
/// \brief Copies a project to a new location.
/// \details The new project is not opened.
/// \param project The project to copy.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param target_path The new location of the project.
/// \pre \li Must not be null.
/// \pre \li Must point to a valid unused path on the system.
/// \param target_name The name of the new project.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param error_out \see errors.h
/// \remark If successful the project connection remains intact. The previous location will still exist.
IKA_API void
ikarus_project_copy(IkarusProject const * project, char const * target_path, char const * target_name, IkarusErrorData * error_out);
/// \brief Deletes a project and all its associated data from the filesystem.
/// \param project The project to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \remark also frees the project.
/// \remark In-Memory projects will just be freed.
/// \remark If deletion fails, the project pointer remains intact.
IKA_API void ikarus_project_delete(IkarusProject * project, IkarusErrorData * error_out);
/// \brief Gets the name of a project. /// \brief Gets the name of a project.
/// \param project The project to get the name of. /// \param project The project to get the name of.
/// \pre \li Must not be null. /// \pre \li Must not be null.
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The name of the project. /// \return The name of the project.
/// \remark Must be freed using #ikarus_free. /// \remark Ownership remains with libikarus, must not be freed.
IKA_API char const * ikarus_project_get_name(IkarusProject const * project, IkarusErrorData * error_out); IKA_API char const * ikarus_project_get_name(IkarusProject const * project, IkarusErrorData * error_out);
/// \brief Sets the name of a project. /// \brief Sets the name of a project.
@ -102,30 +76,9 @@ IKA_API void ikarus_project_set_name(IkarusProject * project, char const * new_n
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The path of the project. /// \return The path of the project.
/// \remark Must be freed using #ikarus_free. /// \remark Ownership remains with libikarus, must not be freed.
IKA_API char const * ikarus_project_get_path(IkarusProject const * project, IkarusErrorData * error_out); IKA_API char const * ikarus_project_get_path(IkarusProject const * project, IkarusErrorData * error_out);
/// \brief Moves a project to a new location.
/// \param project The project to move.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param target_path The new location of the project.
/// \pre \li Must not be null.
/// \pre \li Must point to a valid unused path on the system.
/// \param error_out \see errors.h
/// \remark If successful the project connection remains intact. The previous location will not exist anymore.
/// \remark Due to the nature of filesystems this function may not be atomic.
IKA_API void ikarus_project_move(IkarusProject * project, char const * target_path, IkarusErrorData * error_out);
/// \brief Gets the blueprint root folder of a project.
/// \param project The project to get the blueprint root folder of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The blueprint root folder of the project or null if an error occurs.
/// \remark Must be freed using #ikarus_free.
IKA_API struct IkarusBlueprintFolder * ikarus_project_get_blueprint_root_folder(IkarusProject const * project, IkarusErrorData * error_out);
/// \brief Gets the blueprints of a project. /// \brief Gets the blueprints of a project.
/// \param project The project to get the blueprints of. /// \param project The project to get the blueprints of.
/// \pre \li Must not be null. /// \pre \li Must not be null.
@ -135,7 +88,7 @@ IKA_API struct IkarusBlueprintFolder * ikarus_project_get_blueprint_root_folder(
/// \param blueprints_out_size The size of the buffer. /// \param blueprints_out_size The size of the buffer.
/// \param error_out \see errors.h /// \param error_out \see errors.h
IKA_API void ikarus_project_get_blueprints( IKA_API void ikarus_project_get_blueprints(
IkarusProject const * project, IkarusProject * project,
struct IkarusBlueprint ** blueprints_out, struct IkarusBlueprint ** blueprints_out,
size_t blueprints_out_size, size_t blueprints_out_size,
IkarusErrorData * error_out IkarusErrorData * error_out
@ -147,16 +100,7 @@ IKA_API void ikarus_project_get_blueprints(
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The number of blueprints or undefined if an error occurs. /// \return The number of blueprints or undefined if an error occurs.
IKA_API size_t ikarus_project_get_blueprint_count(IkarusProject const * project, IkarusErrorData * error_out); IKA_API size_t ikarus_project_get_blueprint_count(IkarusProject * project, IkarusErrorData * error_out);
/// \brief Gets the entity root folder of a project.
/// \param project The project to get the entity root folder of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The entity root folder of the project or null if an error occurs.
/// \remark Must be freed using #ikarus_free.
IKA_API struct IkarusEntityFolder * ikarus_project_get_entity_root_folder(IkarusProject const * project, IkarusErrorData * error_out);
/// \brief Gets the entities of a project. /// \brief Gets the entities of a project.
/// \param project The project to get the entities of. /// \param project The project to get the entities of.
@ -167,7 +111,7 @@ IKA_API struct IkarusEntityFolder * ikarus_project_get_entity_root_folder(Ikarus
/// \param entities_out_size The size of the buffer. /// \param entities_out_size The size of the buffer.
/// \param error_out \see errors.h /// \param error_out \see errors.h
IKA_API void ikarus_project_get_entities( IKA_API void ikarus_project_get_entities(
IkarusProject const * project, IkarusProject * project,
struct IkarusEntity ** entities_out, struct IkarusEntity ** entities_out,
size_t entities_out_size, size_t entities_out_size,
IkarusErrorData * error_out IkarusErrorData * error_out
@ -179,7 +123,7 @@ IKA_API void ikarus_project_get_entities(
/// \pre \li Must exist. /// \pre \li Must exist.
/// \param error_out \see errors.h /// \param error_out \see errors.h
/// \return The number of entities or undefined if an error occurs. /// \return The number of entities or undefined if an error occurs.
IKA_API size_t ikarus_project_get_entity_count(IkarusProject const * project, IkarusErrorData * error_out); IKA_API size_t ikarus_project_get_entity_count(IkarusProject * project, IkarusErrorData * error_out);
IKARUS_END_HEADER IKARUS_END_HEADER

46
include/ikarus/values/entity_property_value.h Normal file
View file

@ -0,0 +1,46 @@
#pragma once
/// \file entity_property_value.h
/// \author Folling <folling@ikarus.world>
/// \defgroup entity_property_values EntityPropertyValue
/// \brief Values in relation to an entity and one of its properties.
/// @{
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/values/entity_property_value.h>
IKARUS_BEGIN_HEADER
/// \brief Like an \ref value.h "IkarusValue", but in relation to an entity and one of its properties
struct IkarusEntityPropertyValue;
/// \brief Fetches the entity of an entity property value.
/// \param value The entity property value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The entity of the entity property value.
/// \remark This value is owned by the entity property value and must not be freed directly.
struct IkarusEntity const * ikarus_entity_property_value_get_entity(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out);
/// \brief Fetches the property of an entity property value.
/// \param value The entity property value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The property of the entity property value.
/// \remark This value is owned by the entity property value and must not be freed directly.
struct IkarusProperty const *
ikarus_entity_property_value_get_property(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out);
/// \brief Fetches the value of an entity property value.
/// \param value The entity property value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The value of the entity property value.
/// \remark This value is owned by the entity property value and must not be freed directly.
struct IkarusValue const * ikarus_entity_property_value_get_value(IkarusEntityPropertyValue const * value, IkarusErrorData * error_out);
IKARUS_END_HEADER
/// @}

6
include/ikarus/values/value.h
View file

@ -3,9 +3,6 @@
/// \file value.h /// \file value.h
/// \author Folling <folling@ikarus.world> /// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
/// \defgroup values Values /// \defgroup values Values
/// \brief The values of properties. /// \brief The values of properties.
/// \details Each entity has a value for each property it is associated with. /// \details Each entity has a value for each property it is associated with.
@ -17,6 +14,9 @@
/// property's settings. \see PropertyType /// property's settings. \see PropertyType
/// @{ /// @{
#include <ikarus/errors.h>
#include <ikarus/macros.h>
IKARUS_BEGIN_HEADER IKARUS_BEGIN_HEADER
/// \brief The common type for all values. /// \brief The common type for all values.

2
src/CMakeLists.txt
View file

@ -3,6 +3,8 @@ file(
FILES FILES
"*.hpp" "*.hpp"
"*.cpp" "*.cpp"
"*.h"
"*.c"
) )
set(SOURCE_FILES ${FILES} PARENT_SCOPE) set(SOURCE_FILES ${FILES} PARENT_SCOPE)

64
src/errors.cpp
View file

@ -11,61 +11,39 @@
char const * get_error_info_name(IkarusErrorInfo info) { char const * get_error_info_name(IkarusErrorInfo info) {
switch (info) { switch (info) {
case IkarusErrorInfo_None: return "None"; case IkarusErrorInfo_None: return "None";
case IkarusErrorInfo_Client: return "Client";
case IkarusErrorInfo_Dependency: return "Dependency";
case IkarusErrorInfo_Filesystem: return "Filesystem";
case IkarusErrorInfo_Database: return "Database";
case IkarusErrorInfo_OS: return "OS";
case IkarusErrorInfo_LibIkarus: return "libikarus";
case IkarusErrorInfo_Client_Misuse: return "Misuse"; case IkarusErrorInfo_Client_Misuse: return "Client::Misuse";
case IkarusErrorInfo_Client_InvalidInput: return "InvalidInput"; case IkarusErrorInfo_Client_InvalidInput: return "Client::InvalidInput";
case IkarusErrorInfo_Client_InvalidFormat: return "InvalidFormat"; case IkarusErrorInfo_Client_InvalidFormat: return "Client::InvalidFormat";
case IkarusErrorInfo_Client_ConstraintViolated: return "ConstraintViolated"; case IkarusErrorInfo_Client_ConstraintViolated: return "Client::ConstraintViolated";
case IkarusErrorInfo_Filesystem_NotFound: return "NotFound"; case IkarusErrorInfo_Filesystem_NotFound: return "Filesystem::NotFound";
case IkarusErrorInfo_Filesystem_AlreadyExists: return "AlreadyExists"; case IkarusErrorInfo_Filesystem_AlreadyExists: return "Filesystem::AlreadyExists";
case IkarusErrorInfo_Filesystem_MissingPermissions: return "MissingPermissions"; case IkarusErrorInfo_Filesystem_MissingPermissions: return "Filesystem::MissingPermissions";
case IkarusErrorInfo_Filesystem_InsufficientSpace: return "InsufficientSpace"; case IkarusErrorInfo_Filesystem_InsufficientSpace: return "Filesystem::InsufficientSpace";
case IkarusErrorInfo_Filesystem_InvalidPath: return "InvalidPath"; case IkarusErrorInfo_Filesystem_InvalidPath: return "Filesystem::InvalidPath";
case IkarusErrorInfo_Database_ConnectionFailed: return "ConnectionFailed"; case IkarusErrorInfo_Database_ConnectionFailed: return "Database::ConnectionFailed";
case IkarusErrorInfo_Database_QueryFailed: return "QueryFailed"; case IkarusErrorInfo_Database_QueryFailed: return "Database::QueryFailed";
case IkarusErrorInfo_Database_MigrationFailed: return "MigrationFailed"; case IkarusErrorInfo_Database_MigrationFailed: return "Database::MigrationFailed";
case IkarusErrorInfo_Database_InvalidState: return "InvalidState"; case IkarusErrorInfo_Database_InvalidState: return "Database::InvalidState";
case IkarusErrorInfo_OS_SystemCallFailed: return "SystemCallFailed"; case IkarusErrorInfo_OS_SystemCallFailed: return "OS::SystemCallFailed";
case IkarusErrorInfo_OS_InvalidReturnValue: return "InvalidReturnValue"; case IkarusErrorInfo_OS_InvalidReturnValue: return "OS::InvalidReturnValue";
case IkarusErrorInfo_OS_InsufficientMemory: return "InsufficientMemory"; case IkarusErrorInfo_OS_InsufficientMemory: return "OS::InsufficientMemory";
case IkarusErrorInfo_LibIkarus_InvalidState: return "InvalidState"; case IkarusErrorInfo_LibIkarus_InvalidState: return "LibIkarus::InvalidState";
case IkarusErrorInfo_LibIkarus_Timeout: return "Timeout"; case IkarusErrorInfo_LibIkarus_CannotPerformOperation: return "LibIkarus::CannotPerformOperation";
case IkarusErrorInfo_LibIkarus_Timeout: return "LibIkarus::Timeout";
default: return "Invalid"; default: return "Invalid";
} }
} }
bool ikarus_error_data_is_success(IkarusErrorData const * data) { bool ikarus_error_data_is_success(IkarusErrorData const * data) {
return data->infos[0] == IkarusErrorInfo_None; return data->info == IkarusErrorInfo_None;
} }
bool ikarus_error_data_is_error(IkarusErrorData const * data) { bool ikarus_error_data_is_error(IkarusErrorData const * data) {
return data->infos[0] != IkarusErrorInfo_None; return data->info != IkarusErrorInfo_None;
}
char const * ikarus_error_data_pretty_format(IkarusErrorData const * data) {
if (ikarus_error_data_is_success(data)) {
return "Success";
}
auto const formatted = fmt::format(
"{} - {}",
fmt::join(
data->infos | std::views::take_while(cppbase::pred_ne(IkarusErrorInfo_None)) | std::views::transform(get_error_info_name),
"->"
),
data->message
);
return strndup(formatted.data(), formatted.size());
} }

93
src/errors.hpp Normal file
View file

@ -0,0 +1,93 @@
#pragma once
#include <string_view>
#include <ikarus/errors.h>
inline void safe_strcpy(char * dest, std::string_view src, size_t dest_size) {
for (int i = 0; i < dest_size; ++i) {
if (src[i] == '\0') {
dest[i] = '\0';
return;
}
dest[i] = src[i];
}
}
#define IKARUS_SET_ERROR(msg, err_info) \
if (error_out != nullptr) { \
safe_strcpy(static_cast<char *>(error_out->message), msg, IKARUS_ERROR_DATA_MAX_MESSAGE_LIMIT); \
error_out->info = err_info; \
}
#define IKARUS_FAIL(ret, msg, err_info) \
IKARUS_SET_ERROR(msg, err_info); \
return ret
#define IKARUS_FAIL_IF(condition, ret, msg, err_info) \
if (condition) { \
IKARUS_SET_ERROR(msg, err_info) \
return ret; \
}
#define IKARUS_FAIL_IF_ERROR(ret) \
if (ikarus_error_data_is_error(error_out)) { \
return ret; \
}
#define IKARUS_FAIL_IF_NULL(ptr, ret) IKARUS_FAIL_IF(((ptr) == nullptr), ret, #ptr " must not be null", IkarusErrorInfo_Client_InvalidNull)
#define IKARUS_TRY_OR_FAIL_IMPL(var_name, msg, err_info, ...) \
auto var_name = __VA_ARGS__; \
if (var_name.is_error()) { \
IKARUS_SET_ERROR(fmt::format(msg, var_name.unwrap_error()), err_info); \
return var_name; \
}
#define IKARUS_TRY_OR_FAIL(msg, err_info, ...) IKARUS_TRY_OR_FAIL_IMPL(CPPBASE_UNIQUE_NAME(result), msg, err_info, __VA_ARGS__);
#define IKARUS_TRYRV_OR_FAIL_IMPL(var_name, ret, msg, err_info, ...) \
auto var_name = __VA_ARGS__; \
if (var_name.is_error()) { \
IKARUS_SET_ERROR(fmt::format(msg, var_name.unwrap_error()), err_info); \
return ret; \
}
#define IKARUS_TRYRV_OR_FAIL(ret, msg, err_info, ...) \
IKARUS_TRYRV_OR_FAIL_IMPL(CPPBASE_UNIQUE_NAME(result), ret, msg, err_info, __VA_ARGS__);
#define IKARUS_VTRY_OR_FAIL_IMPL(var_name, value, msg, err_info, ...) \
auto var_name = __VA_ARGS__; \
if (var_name.is_error()) { \
IKARUS_SET_ERROR(fmt::format(msg, var_name.unwrap_error()), err_info); \
return var_name; \
} \
value = var_name.unwrap_value()
#define IKARUS_VTRY_OR_FAIL(value, msg, err_info, ...) \
IKARUS_VTRY_OR_FAIL_IMPL(CPPBASE_UNIQUE_NAME(result), value, msg, err_info, __VA_ARGS__);
#define IKARUS_VTRYRV_OR_FAIL_IMPL(var_name, value, ret, msg, err_info, ...) \
auto var_name = __VA_ARGS__; \
if (var_name.is_error()) { \
IKARUS_SET_ERROR(fmt::format(msg, var_name.unwrap_error()), err_info); \
return ret; \
} \
value = var_name.unwrap_value()
#define IKARUS_VTRYRV_OR_FAIL(value, ret, msg, err_info, ...) \
IKARUS_VTRYRV_OR_FAIL_IMPL(CPPBASE_UNIQUE_NAME(result), value, ret, msg, err_info, __VA_ARGS__);
#define IKARUS_FAIL_IF_OBJECT_MISSING_IMPL(var_name, obj, ret) \
IKARUS_VTRYRV_OR_FAIL( \
bool const var_name, \
ret, \
"unable to check whether object exists: {}", \
IkarusErrorInfo_Database_QueryFailed, \
(obj)->project->db->template query_one<bool>("SELECT EXISTS(SELECT 1 FROM `objects` WHERE `id` = ?)", (obj)->id) \
) \
\
IKARUS_FAIL_IF(!(var_name), ret, "object does not exist", IkarusErrorInfo_Client_Misuse);
#define IKARUS_FAIL_IF_OBJECT_MISSING(obj, ret) IKARUS_FAIL_IF_OBJECT_MISSING_IMPL(CPPBASE_UNIQUE_NAME(exists), obj, ret);

174
src/objects/blueprint.cpp
View file

@ -1,11 +1,13 @@
#include "ikarus/objects/blueprint.h" #include "ikarus/objects/blueprint.h"
#include "ikarus/objects/properties/property.h"
#include "objects/blueprint.hpp" #include "objects/blueprint.hpp"
#include <cppbase/logger.hpp> #include <cppbase/logger.hpp>
#include <cppbase/result.hpp> #include <cppbase/result.hpp>
#include <cppbase/strings.hpp> #include <cppbase/strings.hpp>
#include <errors.hpp>
#include <objects/entity.hpp> #include <objects/entity.hpp>
#include <objects/properties/property.hpp> #include <objects/properties/property.hpp>
#include <persistence/project.hpp> #include <persistence/project.hpp>
@ -13,117 +15,149 @@
IkarusBlueprint::IkarusBlueprint(IkarusProject * project, IkarusId id): IkarusBlueprint::IkarusBlueprint(IkarusProject * project, IkarusId id):
IkarusObject{project, id} {} IkarusObject{project, id} {}
IkarusBlueprint * ikarus_blueprint_create(struct IkarusProject * project, char const * name) { IkarusBlueprint * ikarus_blueprint_create(struct IkarusProject * project, char const * name, IkarusErrorData * error_out) {
if (cppbase::is_empty_or_blank(name)) { IKARUS_FAIL_IF_NULL(project, nullptr);
project->set_error("blueprint name must not be empty", true, IkarusErrorInfo_Source_Client, IkarusErrorInfo_Type_Client_Input); IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(name), nullptr, "name must not be empty", IkarusErrorInfo_Client_InvalidInput);
return nullptr; IKARUS_VTRYRV_OR_FAIL(
} IkarusId const id,
nullptr,
project->db "failed to create blueprint: {}",
->transact([name](auto * db) { IkarusErrorInfo_Database_QueryFailed,
project->db->transact([name](auto * db) -> cppbase::Result<IkarusId, sqlitecpp::TransactionError> {
TRY(db->execute("INSERT INTO `objects`(`type`, `name`) VALUES(?, ?, ?)", IkarusObjectType_Blueprint, name)); TRY(db->execute("INSERT INTO `objects`(`type`, `name`) VALUES(?, ?, ?)", IkarusObjectType_Blueprint, name));
auto id = ikarus_id_from_data_and_type(db->last_insert_rowid(), IkarusObjectType_Blueprint); auto id = ikarus_id_from_data_and_type(db->last_insert_rowid(), IkarusObjectType_Blueprint);
TRY(db->execute("INSERT INTO `blueprints`(`id`) VALUES(?)", id)); TRY(db->execute("INSERT INTO `blueprints`(`id`) VALUES(?)", id));
return cppbase::ok(); return cppbase::ok(id);
}) })
.on_error([project](auto const & err) { );
project->set_error(
fmt::format("failed to create blueprint: {}", err), return project->get_blueprint(id);
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
});
} }
void ikarus_blueprint_delete(IkarusBlueprint * blueprint) { void ikarus_blueprint_delete(IkarusBlueprint * blueprint, IkarusErrorData * error_out) {
blueprint->project->db->execute("DELETE FROM `objects` WHERE `id` = ?", blueprint->id).on_error([blueprint](auto const & err) { IKARUS_FAIL_IF_NULL(blueprint, );
blueprint->project->set_error( IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
fmt::format("failed to delete blueprint from objects table: {}", err),
true, IKARUS_TRYRV_OR_FAIL(
IkarusErrorInfo_Source_SubSystem, ,
IkarusErrorInfo_Type_SubSystem_Database "unable to delete blueprint: {}",
); IkarusErrorInfo_Database_QueryFailed,
}); blueprint->project->db->execute("DELETE FROM `objects` WHERE `id` = ?", blueprint->id)
);
blueprint->project->uncache(blueprint);
} }
void ikarus_blueprint_get_properties( void ikarus_blueprint_get_properties(
IkarusBlueprint const * blueprint, IkarusBlueprint const * blueprint,
struct IkarusProperty ** properties_out, struct IkarusProperty ** properties_out,
size_t properties_out_size size_t properties_out_size,
IkarusErrorData * error_out
) { ) {
IkarusId ids[properties_out_size]; IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_FAIL_IF_NULL(properties_out, );
TRYRV( if (properties_out_size == 0) {
return;
}
std::tuple<IkarusId, IkarusPropertyType> ids_and_types[properties_out_size];
IKARUS_TRYRV_OR_FAIL(
, ,
blueprint->project->db "unable to fetch blueprint properties from database: {}",
->query_many_buffered<IkarusId>("SELECT `id` FROM `properties` WHERE `source` = ?", ids, properties_out_size, blueprint->id) IkarusErrorInfo_Database_QueryFailed,
.on_error([&](auto const & err) { blueprint->project->db->query_many_buffered<IkarusId, IkarusPropertyType>(
blueprint->project->set_error( "SELECT `id` FROM `properties` WHERE `source` = ?",
fmt::format("failed to fetch blueprint properties from database: {}", err), ids_and_types,
true, properties_out_size,
IkarusErrorInfo_Source_SubSystem, blueprint->id
IkarusErrorInfo_Type_SubSystem_Database )
); )
})
);
// not atomic, could be switched to two loops if necessary
for (size_t i = 0; i < properties_out_size; ++i) { for (size_t i = 0; i < properties_out_size; ++i) {
IkarusId id = ids[i]; auto [id, type] = ids_and_types[i];
VTRYRV(auto const type, , IkarusProperty::get_property_type(blueprint->project, id));
properties_out[i] = blueprint->project->get_property(id, type); properties_out[i] = blueprint->project->get_property(id, type);
} }
} }
size_t ikarus_blueprint_get_property_count(IkarusBlueprint const * blueprint) { size_t ikarus_blueprint_get_property_count(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
return blueprint->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `properties` WHERE `source` = ?", blueprint->id) IKARUS_FAIL_IF_NULL(blueprint, 0);
.unwrap_value_or(0); IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, 0);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
0,
"unable to fetch blueprint property count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
blueprint->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `properties` WHERE `source` = ?", blueprint->id)
);
return ret;
} }
void ikarus_blueprint_get_linked_entities( void ikarus_blueprint_get_linked_entities(
IkarusBlueprint const * blueprint, IkarusBlueprint const * blueprint,
struct IkarusEntity ** entities_out, struct IkarusEntity ** entities_out,
size_t entities_out_size size_t entities_out_size,
IkarusErrorData * error_out
) { ) {
IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_FAIL_IF_NULL(entities_out, );
if (entities_out_size == 0) {
return;
}
IkarusId ids[entities_out_size]; IkarusId ids[entities_out_size];
TRYRV( IKARUS_TRYRV_OR_FAIL(
, ,
blueprint->project->db "unable to fetch blueprint linked entities from database: {}",
->query_many_buffered<IkarusId>( IkarusErrorInfo_Database_QueryFailed,
"SELECT `entity` FROM `entity_blueprint_links` WHERE `blueprint` = ?", blueprint->project->db->query_many_buffered<IkarusId>(
ids, "SELECT `entity` FROM `entity_blueprint_links` WHERE `blueprint` = ?",
entities_out_size, ids,
blueprint->id entities_out_size,
) blueprint->id
.on_error([&](auto const & err) { )
blueprint->project->set_error( )
fmt::format("failed to fetch linked entities from database: {}", err),
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
})
);
for (size_t i = 0; i < entities_out_size; ++i) { for (size_t i = 0; i < entities_out_size; ++i) {
entities_out[i] = blueprint->project->get_entity(ids[i]); entities_out[i] = blueprint->project->get_entity(ids[i]);
} }
} }
size_t ikarus_blueprint_get_linked_entity_count(IkarusBlueprint const * blueprint) { size_t ikarus_blueprint_get_linked_entity_count(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
return blueprint->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `entity_blueprint_links` WHERE `blueprint` = ?", blueprint->id) IKARUS_FAIL_IF_NULL(blueprint, 0);
.unwrap_value_or(0); IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, 0);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
0,
"unable to fetch blueprint linked entity count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
blueprint->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `entity_blueprint_links` WHERE `blueprint` = ?", blueprint->id)
);
return ret;
} }
IkarusObject * ikarus_blueprint_to_object(IkarusBlueprint * blueprint) { // No existence checks here for performance reasons. All methods on IkarusObject perform this check anyway.
IkarusObject * ikarus_blueprint_to_object(IkarusBlueprint * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(blueprint, nullptr);
return static_cast<IkarusObject *>(blueprint); return static_cast<IkarusObject *>(blueprint);
} }
IkarusObject const * ikarus_blueprint_to_object_const(IkarusBlueprint const * blueprint) { IkarusObject const * ikarus_blueprint_to_object_const(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(blueprint, nullptr);
return static_cast<IkarusObject const *>(blueprint); return static_cast<IkarusObject const *>(blueprint);
} }

297
src/objects/entity.cpp
View file

@ -1,36 +1,289 @@
#include "entity.hpp" #include "entity.hpp"
#include "values/value.hpp"
#include <cppbase/strings.hpp> #include <cppbase/strings.hpp>
#include <errors.hpp>
#include <objects/blueprint.hpp> #include <objects/blueprint.hpp>
#include <objects/util.hpp> #include <objects/properties/property.hpp>
#include <persistence/project.hpp> #include <persistence/project.hpp>
#include <values/entity_property_value.hpp>
IkarusEntity * ikarus_entity_create(struct IkarusProject * project, char const * name) { IkarusEntity * ikarus_entity_create(struct IkarusProject * project, char const * name, IkarusErrorData * error_out) {
return ikarus::util::insert_object( IKARUS_FAIL_IF_NULL(project, nullptr);
project, IKARUS_FAIL_IF_NULL(name, nullptr);
IkarusObjectType_Entity, IKARUS_FAIL_IF(cppbase::is_empty_or_blank(name), nullptr, "name must not be empty", IkarusErrorInfo_Client_InvalidInput);
name,
[](auto * db, IkarusId id) { return db->execute("INSERT INTO `entities`(`id`) VALUES(?)", id); }, IKARUS_VTRYRV_OR_FAIL(
[project](IkarusId id) { return project->get_entity(id); } IkarusId const id,
).unwrap_value_or(nullptr); nullptr,
"failed to create entity: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->transact([name](auto * db) -> cppbase::Result<IkarusId, sqlitecpp::TransactionError> {
TRY(db->execute("INSERT INTO `objects`(`type`, `name`) VALUES(?, ?, ?)", IkarusObjectType_Entity, name));
auto id = ikarus_id_from_data_and_type(db->last_insert_rowid(), IkarusObjectType_Entity);
TRY(db->execute("INSERT INTO `entities`(`id`) VALUES(?)", id));
return cppbase::ok(id);
})
);
return project->get_entity(id);
} }
void ikarus_entity_delete(IkarusEntity * entity) { void ikarus_entity_delete(IkarusEntity * entity, IkarusErrorData * error_out) {
ikarus::util::delete_object(entity); IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to delete entity: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute("DELETE FROM `objects` WHERE `id` == ?", entity->id)
);
entity->project->uncache(entity);
} }
bool ikarus_entity_is_linked_to_blueprint(IkarusEntity const * entity, struct IkarusBlueprint const * blueprint) { bool ikarus_entity_is_linked_to_blueprint(
return ikarus::util::check_exists( IkarusEntity const * entity,
entity, struct IkarusBlueprint const * blueprint,
ikarus::util::ExistsQueryData<IkarusId>{ IkarusErrorData * error_out
.table_name = "entity_blueprint_links", ) {
.where_field_name = "blueprint", IKARUS_FAIL_IF_NULL(entity, false);
.where_field_value = blueprint->id, IKARUS_FAIL_IF_OBJECT_MISSING(entity, false);
.relation_desc = "linked blueprints" IKARUS_FAIL_IF_NULL(blueprint, false);
} IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, false);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
false,
"unable to check whether entity is linked to blueprint",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<bool>(
"SELECT EXISTS(SELECT 1 FROM `entity_blueprint_links` WHERE `entity` = ? AND `blueprint` = ?)",
entity->id,
blueprint->id
)
) )
.unwrap_value_or(false);
return ret;
} }
bool ikarus_entity_link_to_blueprint(IkarusEntity * entity, struct IkarusBlueprint * blueprint) {} void ikarus_entity_link_to_blueprint(IkarusEntity * entity, struct IkarusBlueprint * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to link entity to blueprint: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"INSERT INTO `entity_blueprint_links`(`entity`, `blueprint`) VALUES(?, ?) ON CONFLICT(`entity`, `blueprint`) DO NOTHING",
entity->id,
blueprint->id
)
);
}
void ikarus_entity_unlink_from_blueprint(IkarusEntity * entity, struct IkarusBlueprint * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to unlink entity from blueprint: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db
->execute("DELETE FROM `entity_blueprint_links` WHERE `entity` = ? AND `blueprint` = ?", entity->id, blueprint->id)
);
}
void ikarus_entity_get_linked_blueprints(
IkarusEntity const * entity,
struct IkarusBlueprint ** blueprints_out,
size_t blueprints_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NULL(blueprints_out, );
if (blueprints_out_size == 0) {
return;
}
IkarusId ids[blueprints_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch entity linked blueprints from database: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_many_buffered<IkarusId>(
"SELECT `blueprint` FROM `entity_blueprint_links` WHERE `entity` = ?",
ids,
blueprints_out_size,
entity->id
)
)
for (size_t i = 0; i < blueprints_out_size; ++i) {
blueprints_out[i] = entity->project->get_blueprint(ids[i]);
}
}
size_t ikarus_entity_get_linked_blueprint_count(IkarusEntity const * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, 0);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, 0);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
0,
"unable to fetch entity linked blueprint count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `entity_blueprint_links` WHERE `entity` = ?", entity->id)
);
return ret;
}
bool ikarus_entity_has_property(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, false);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, false);
IKARUS_FAIL_IF_NULL(property, false);
IKARUS_FAIL_IF_OBJECT_MISSING(property, false);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
false,
"unable to check whether entity has property: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<bool>(
"SELECT EXISTS(SELECT 1 FROM `entity_properties` WHERE `entity` = ? AND `property` = ?)",
entity->id,
property->id
)
)
return ret;
}
void ikarus_entity_get_properties(
IkarusEntity const * entity,
struct IkarusProperty ** properties_out,
size_t properties_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NULL(properties_out, );
if (properties_out_size == 0) {
return;
}
std::tuple<IkarusId, IkarusPropertyType> ids_and_types[properties_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch entity properties from database: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_many_buffered<IkarusId, IkarusPropertyType>(
"SELECT `property`, `type` FROM `properties` WHERE `source` = ?",
ids_and_types,
properties_out_size,
entity->id
)
)
for (size_t i = 0; i < properties_out_size; ++i) {
auto [id, type] = ids_and_types[i];
properties_out[i] = entity->project->get_property(id, type);
}
}
size_t ikarus_entity_get_property_count(IkarusEntity const * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, 0);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, 0);
IKARUS_VTRYRV_OR_FAIL(
size_t const ret,
0,
"unable to fetch entity property count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<int64_t>("SELECT COUNT(*) FROM `properties` WHERE `source` = ?", entity->id)
);
return ret;
}
struct IkarusEntityPropertyValue *
ikarus_entity_get_value(IkarusEntity const * entity, struct IkarusProperty const * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, nullptr);
IKARUS_FAIL_IF_NULL(property, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(property, nullptr);
auto * value = fetch_value_from_db(
entity->project,
error_out,
"SELECT IFNULL((SELECT `value` FROM `values` WHERE `entity` = ? AND `property` = ?), (SELECT `default_value` FROM `properties` WHERE `id` = ?))",
entity->id,
property->id,
property->id
);
IKARUS_FAIL_IF_ERROR(nullptr);
return new IkarusEntityPropertyValue{
.entity = entity,
.property = property,
.value = value,
};
}
void ikarus_entity_set_value(
IkarusEntity * entity,
struct IkarusProperty const * property,
struct IkarusEntityPropertyValue * value,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
IKARUS_FAIL_IF_NULL(value, );
auto value_json_str = boost::json::serialize(value->value->to_json());
IKARUS_TRYRV_OR_FAIL(
,
"unable to set entity property value: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"INSERT INTO `values`(`entity`, `property`, `value`) VALUES(?, ?, ?) ON CONFLICT(`entity`, `property`) DO UPDATE SET `value` = ?",
entity->id,
property->id,
value_json_str,
value_json_str
)
);
}
// No existence checks here for performance reasons. All methods on IkarusObject perform this check anyway.
struct IkarusObject * ikarus_entity_to_object(IkarusEntity * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
return static_cast<IkarusObject *>(entity);
}
struct IkarusObject const * ikarus_entity_to_object_const(IkarusEntity const * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
return static_cast<IkarusObject const *>(entity);
}

104
src/objects/object.cpp
View file

@ -1,5 +1,109 @@
#include "object.hpp" #include "object.hpp"
#include <fmt/format.h>
#include <ikarus/objects/object.h>
#include <errors.hpp>
#include <objects/blueprint.hpp>
#include <objects/entity.hpp>
#include <objects/properties/property.hpp>
#include <persistence/project.hpp>
IkarusObject::IkarusObject(IkarusProject * project, IkarusId id): IkarusObject::IkarusObject(IkarusProject * project, IkarusId id):
project{project}, project{project},
id{id} {} id{id} {}
IkarusProject * ikarus_object_get_project(IkarusObject const * object, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(object, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(object, nullptr);
return object->project;
}
bool ikarus_object_is_equal(IkarusObject const * lhs, IkarusObject const * rhs, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(lhs, false);
IKARUS_FAIL_IF_OBJECT_MISSING(lhs, false);
IKARUS_FAIL_IF_NULL(rhs, false);
IKARUS_FAIL_IF_OBJECT_MISSING(rhs, false);
return lhs->id == rhs->id;
}
void ikarus_object_visit(
IkarusObject * object,
void (*blueprint_visitor)(struct IkarusBlueprint *, void *),
void (*property_visitor)(struct IkarusProperty *, void *),
void (*entity_visitor)(struct IkarusEntity *, void *),
void * data,
IkarusErrorData * error_out
) {
struct Data {
void (*blueprint_visitor)(struct IkarusBlueprint *, void *);
void (*property_visitor)(struct IkarusProperty *, void *);
void (*entity_visitor)(struct IkarusEntity *, void *);
void * data;
};
Data passthru_data{
blueprint_visitor,
property_visitor,
entity_visitor,
data,
};
ikarus_object_visit_const(
object,
[](IkarusBlueprint const * blueprint, void * data) {
auto const * passthru_data = static_cast<Data *>(data);
passthru_data->blueprint_visitor(const_cast<IkarusBlueprint *>(blueprint), passthru_data->data);
},
[](IkarusProperty const * property, void * data) {
auto const * passthru_data = static_cast<Data *>(data);
passthru_data->property_visitor(const_cast<IkarusProperty *>(property), passthru_data->data);
},
[](IkarusEntity const * entity, void * data) {
auto const * passthru_data = static_cast<Data *>(data);
passthru_data->entity_visitor(const_cast<IkarusEntity *>(entity), passthru_data->data);
},
&passthru_data,
error_out
);
}
void ikarus_object_visit_const(
IkarusObject const * object,
void (*blueprint_visitor)(struct IkarusBlueprint const *, void *),
void (*property_visitor)(struct IkarusProperty const *, void *),
void (*entity_visitor)(struct IkarusEntity const *, void *),
void * data,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(object, );
IKARUS_FAIL_IF_OBJECT_MISSING(object, );
switch (ikarus_id_get_object_type(object->id)) {
case IkarusObjectType_Entity: {
auto const * entity = dynamic_cast<IkarusEntity const *>(object);
IKARUS_FAIL_IF(entity == nullptr, , "object with entity id wasn't a entity", IkarusErrorInfo_LibIkarus_InvalidState);
entity_visitor(entity, data);
}
case IkarusObjectType_Blueprint: {
auto const * blueprint = dynamic_cast<IkarusBlueprint const *>(object);
IKARUS_FAIL_IF(blueprint == nullptr, , "object with blueprint id wasn't a blueprint", IkarusErrorInfo_LibIkarus_InvalidState);
blueprint_visitor(blueprint, data);
}
case IkarusObjectType_Property: {
auto const * property = dynamic_cast<IkarusProperty const *>(object);
IKARUS_FAIL_IF(property == nullptr, , "object with property id wasn't a property", IkarusErrorInfo_LibIkarus_InvalidState);
property_visitor(property, data);
}
default: {
IKARUS_FAIL(
,
fmt::format("unknown object type: {}", ikarus_object_type_to_string(ikarus_id_get_object_type(object->id))),
IkarusErrorInfo_LibIkarus_InvalidState
);
}
}
}

4
src/objects/object.hpp
View file

@ -1,9 +1,5 @@
#pragma once #pragma once
#include <cppbase/result.hpp>
#include <sqlitecpp/errors.hpp>
#include <ikarus/id.h> #include <ikarus/id.h>
struct IkarusObject { struct IkarusObject {

29
src/objects/properties/number_property.cpp
View file

@ -1,4 +1,33 @@
#include "number_property.hpp" #include "number_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <objects/properties/property_source.hpp>
#include <objects/properties/util.hpp>
#include <values/value.hpp>
IkarusNumberProperty::IkarusNumberProperty(IkarusProject * project, IkarusId id): IkarusNumberProperty::IkarusNumberProperty(IkarusProject * project, IkarusId id):
IkarusProperty{project, id, this} {} IkarusProperty{project, id, this} {}
IkarusNumberProperty * ikarus_number_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
IkarusErrorData * error_out
) {
return ikarus::util::create_property<IkarusNumberProperty>(project, name, property_source, error_out);
}
IkarusNumberValue * ikarus_number_property_get_default_value(IkarusNumberProperty * property, IkarusErrorData * error_out) {
return ikarus::util::get_default_value<IkarusNumberProperty>(property, error_out);
}
void ikarus_number_property_set_default_value(
IkarusNumberProperty * property,
IkarusNumberValue * new_default_value,
IkarusErrorData * error_out
) {
ikarus::util::set_default_value<IkarusNumberProperty>(property, new_default_value, error_out);
}

11
src/objects/properties/number_property.hpp
View file

@ -1,8 +1,15 @@
#pragma once #pragma once
#include <objects/properties/property.hpp> #include <ikarus/objects/properties/property_type.h>
#include <objects/properties/property.hpp>
#include <values/number_value.hpp>
struct IkarusNumberProperty : IkarusProperty {
public:
using value_type = IkarusNumberValue;
constexpr auto static PropertyType = IkarusPropertyType_Number;
struct IkarusNumberProperty final : IkarusProperty {
public: public:
IkarusNumberProperty(struct IkarusProject * project, IkarusId id); IkarusNumberProperty(struct IkarusProject * project, IkarusId id);
}; };

131
src/objects/properties/property.cpp
View file

@ -2,8 +2,10 @@
#include <cppbase/logger.hpp> #include <cppbase/logger.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property_type.h> #include <ikarus/objects/properties/property_type.h>
#include <errors.hpp>
#include <objects/properties/property_source.hpp> #include <objects/properties/property_source.hpp>
#include <persistence/project.hpp> #include <persistence/project.hpp>
#include <sys/stat.h> #include <sys/stat.h>
@ -11,101 +13,66 @@
IkarusProperty::IkarusProperty(IkarusProject * project, IkarusId id, Data data): IkarusProperty::IkarusProperty(IkarusProject * project, IkarusId id, Data data):
IkarusObject{project, id}, IkarusObject{project, id},
_data{data} {} data{data} {}
IkarusProperty::Data & IkarusProperty::get_data() { IKA_API void ikarus_property_delete(IkarusProperty * property, IkarusErrorData * error_out) {
return _data; IKARUS_FAIL_IF_NULL(property, );
} IKARUS_FAIL_IF_OBJECT_MISSING(property, );
IkarusProperty::Data const & IkarusProperty::get_data() const { IKARUS_TRYRV_OR_FAIL(
return _data;
}
cppbase::Result<IkarusPropertyType, sqlitecpp::SingleQueryError> IkarusProperty::get_property_type(IkarusProject * project, IkarusId id) {
VTRY(
auto const type,
project->db->query_one<int>("SELECT `type` FROM `properties` WHERE `id` = ?", id).on_error([project](auto const & err) {
project->set_error(
fmt::format("failed to fetch unboxed property type: {}", err),
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
})
);
return cppbase::ok(static_cast<IkarusPropertyType>(type));
}
IKA_API void ikarus_property_delete(IkarusProperty * property) {
TRYRV(
, ,
property->project->db->execute("DELETE FROM `objects` WHERE `id` = ?", property->id).on_error([property](auto const & err) { "unable to delete property: {}",
property->project->set_error( IkarusErrorInfo_Database_QueryFailed,
fmt::format("failed to delete property from objects table: {}", err), property->project->db->execute("DELETE FROM `objects` WHERE `id` = ?", property->id)
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
})
); );
property->project->uncache(property); property->project->uncache(property);
} }
IkarusPropertyType ikarus_property_get_type(IkarusProperty const * property) { IkarusPropertyType ikarus_property_get_type(IkarusProperty const * property, IkarusErrorData * error_out) {
return IkarusProperty::get_property_type(property->project, property->id).unwrap_value_or(IkarusPropertyType_Toggle); IKARUS_FAIL_IF_NULL(property, IkarusPropertyType_Toggle);
IKARUS_FAIL_IF_OBJECT_MISSING(property, IkarusPropertyType_Toggle);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
IkarusPropertyType_Toggle,
"unable to fetch property type from database: {}",
IkarusErrorInfo_Database_QueryFailed,
property->project->db->query_one<int>("SELECT `type` FROM `properties` WHERE `id` = ?", property->id)
);
return static_cast<IkarusPropertyType>(ret);
} }
IkarusPropertySource const * ikarus_property_get_source(IkarusProperty const * property) { IkarusPropertySource const * ikarus_property_get_source(IkarusProperty const * property, IkarusErrorData * error_out) {
VTRYRV( IKARUS_FAIL_IF_NULL(property, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(property, nullptr);
IKARUS_VTRYRV_OR_FAIL(
auto const source, auto const source,
nullptr, nullptr,
property->project->db "unable to fetch property source from database: {}",
->query_one<int>("SELECT `source` FROM `properties` WHERE `id` = ?", property->id) IkarusErrorInfo_Database_QueryFailed,
.on_error([property](auto const & err) { property->project->db->query_one<IkarusId>("SELECT `source` FROM `properties` WHERE `id` = ?", property->id)
property->project->set_error(
fmt::format("failed to fetch property's source: {}", err),
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
})
); );
switch (ikarus_id_get_object_type(source)) { switch (ikarus_id_get_object_type(source)) {
case IkarusObjectType_Blueprint: return new IkarusPropertySource{property->project->get_blueprint(source)}; case IkarusObjectType_Blueprint: return new IkarusPropertySource{property->project->get_blueprint(source)};
case IkarusObjectType_Entity: return new IkarusPropertySource{property->project->get_entity(source)}; case IkarusObjectType_Entity: return new IkarusPropertySource{property->project->get_entity(source)};
default: { default:
property->project->set_error( IKARUS_FAIL(
fmt::format("PropertySource is neither blueprint nor entity"), nullptr,
true, fmt::format("invalid property source type: {}", ikarus_object_type_to_string(ikarus_id_get_object_type(source))),
IkarusErrorInfo_Source_LibIkarus, IkarusErrorInfo_LibIkarus_InvalidState
IkarusErrorInfo_Type_LibIkarus_InvalidState
); );
return nullptr;
}
} }
} }
IkarusValue * ikarus_property_get_default_value(IkarusProperty const * property) { IkarusValue * ikarus_property_get_default_value(IkarusProperty const * property, IkarusErrorData * error_out) {
VTRYRV( IKARUS_FAIL_IF_NULL(property, nullptr);
auto const value, IKARUS_FAIL_IF_OBJECT_MISSING(property, nullptr);
nullptr,
property->project->db
->query_one<int>("SELECT `default_value` FROM `properties` WHERE `id` = ?", property->id)
.on_error([property](auto const & err) {
property->project->set_error(
fmt::format("failed to fetch property's default value: {}", err),
true,
IkarusErrorInfo_Source_SubSystem,
IkarusErrorInfo_Type_SubSystem_Database
);
})
);
return IkarusValue::from_json(value).unwrap_value_or(nullptr); return fetch_value_from_db(property->project, error_out, "SELECT `default_value` FROM `properties` WHERE `id` = ?", property->id);
} }
void ikarus_property_visit( void ikarus_property_visit(
@ -113,15 +80,19 @@ void ikarus_property_visit(
void (*toggle_property_visitor)(struct IkarusToggleProperty *, void *), void (*toggle_property_visitor)(struct IkarusToggleProperty *, void *),
void (*number_property_visitor)(struct IkarusNumberProperty *, void *), void (*number_property_visitor)(struct IkarusNumberProperty *, void *),
void (*text_property_visitor)(struct IkarusTextProperty *, void *), void (*text_property_visitor)(struct IkarusTextProperty *, void *),
void * data void * data,
IkarusErrorData * error_out
) { ) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
std::visit( std::visit(
cppbase::overloaded{ cppbase::overloaded{
[toggle_property_visitor, data](IkarusToggleProperty * property) { toggle_property_visitor(property, data); }, [toggle_property_visitor, data](IkarusToggleProperty * property) { toggle_property_visitor(property, data); },
[number_property_visitor, data](IkarusNumberProperty * property) { number_property_visitor(property, data); }, [number_property_visitor, data](IkarusNumberProperty * property) { number_property_visitor(property, data); },
[text_property_visitor, data](IkarusTextProperty * property) { text_property_visitor(property, data); } [text_property_visitor, data](IkarusTextProperty * property) { text_property_visitor(property, data); }
}, },
property->get_data() property->data
); );
} }
@ -130,18 +101,24 @@ void ikarus_property_visit_const(
void (*toggle_property_visitor)(struct IkarusToggleProperty const *, void *), void (*toggle_property_visitor)(struct IkarusToggleProperty const *, void *),
void (*number_property_visitor)(struct IkarusNumberProperty const *, void *), void (*number_property_visitor)(struct IkarusNumberProperty const *, void *),
void (*text_property_visitor)(struct IkarusTextProperty const *, void *), void (*text_property_visitor)(struct IkarusTextProperty const *, void *),
void * data void * data,
IkarusErrorData * error_out
) { ) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
std::visit( std::visit(
cppbase::overloaded{ cppbase::overloaded{
[toggle_property_visitor, data](IkarusToggleProperty const * property) { toggle_property_visitor(property, data); }, [toggle_property_visitor, data](IkarusToggleProperty const * property) { toggle_property_visitor(property, data); },
[number_property_visitor, data](IkarusNumberProperty const * property) { number_property_visitor(property, data); }, [number_property_visitor, data](IkarusNumberProperty const * property) { number_property_visitor(property, data); },
[text_property_visitor, data](IkarusTextProperty const * property) { text_property_visitor(property, data); } [text_property_visitor, data](IkarusTextProperty const * property) { text_property_visitor(property, data); }
}, },
property->get_data() property->data
); );
} }
// No existence checks here for performance reasons. All methods on IkarusObject perform this check anyway.
IkarusObject * ikarus_property_to_object(IkarusProperty * property) { IkarusObject * ikarus_property_to_object(IkarusProperty * property) {
return static_cast<IkarusObject *>(property); return static_cast<IkarusObject *>(property);
} }

17
src/objects/properties/property.hpp
View file

@ -2,23 +2,12 @@
#include <variant> #include <variant>
#include <cppbase/result.hpp>
#include <sqlitecpp/errors.hpp>
#include <ikarus/objects/properties/property_type.h>
#include <objects/object.hpp> #include <objects/object.hpp>
struct IkarusProperty : IkarusObject { struct IkarusProperty : IkarusObject {
public: public:
using Data = std::variant<struct IkarusToggleProperty *, struct IkarusNumberProperty *, struct IkarusTextProperty *>; using Data = std::variant<struct IkarusToggleProperty *, struct IkarusNumberProperty *, struct IkarusTextProperty *>;
public:
/// \brief Helper to fetch a type for a property that isn't yet wrapped in an object
[[nodiscard]] static cppbase::Result<IkarusPropertyType, sqlitecpp::SingleQueryError>
get_property_type(struct IkarusProject * project, IkarusId id);
public: public:
IkarusProperty(struct IkarusProject * project, IkarusId id, Data data); IkarusProperty(struct IkarusProject * project, IkarusId id, Data data);
@ -31,9 +20,5 @@ public:
~IkarusProperty() override = default; ~IkarusProperty() override = default;
public: public:
[[nodiscard]] Data & get_data(); Data data;
[[nodiscard]] Data const & get_data() const;
private:
Data _data;
}; };

12
src/objects/properties/property_source.cpp
View file

@ -3,10 +3,22 @@
#include <boost/functional/overloaded_function.hpp> #include <boost/functional/overloaded_function.hpp>
#include <objects/blueprint.hpp> #include <objects/blueprint.hpp>
#include <objects/entity.hpp>
#include <cppbase/templates.hpp>
IkarusPropertySource::IkarusPropertySource(Data data): IkarusPropertySource::IkarusPropertySource(Data data):
data{data} {} data{data} {}
IkarusId IkarusPropertySource::get_id() const {
return boost::variant2::visit(
cppbase::overloaded {
[](IkarusBlueprint const * blueprint) { return blueprint->id; },
[](IkarusEntity const * entity) { return entity->id; }
},
data
);
}
IkarusPropertySource * ikarus_property_source_create_blueprint(IkarusBlueprint * blueprint) { IkarusPropertySource * ikarus_property_source_create_blueprint(IkarusBlueprint * blueprint) {
return new IkarusPropertySource{blueprint}; return new IkarusPropertySource{blueprint};
} }

5
src/objects/properties/property_source.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <boost/variant2.hpp> #include <boost/variant2.hpp>
#include <ikarus/id.h>
#include <ikarus/objects/properties/property_source.h> #include <ikarus/objects/properties/property_source.h>
struct IkarusPropertySource { struct IkarusPropertySource {
@ -19,6 +19,9 @@ public:
virtual ~IkarusPropertySource() = default; virtual ~IkarusPropertySource() = default;
public:
[[nodiscard]] IkarusId get_id() const;
public: public:
Data data; Data data;
}; };

29
src/objects/properties/text_property.cpp
View file

@ -1,4 +1,33 @@
#include "text_property.hpp" #include "text_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <objects/properties/property_source.hpp>
#include <objects/properties/util.hpp>
#include <values/value.hpp>
IkarusTextProperty::IkarusTextProperty(IkarusProject * project, IkarusId id): IkarusTextProperty::IkarusTextProperty(IkarusProject * project, IkarusId id):
IkarusProperty{project, id, this} {} IkarusProperty{project, id, this} {}
IkarusTextProperty * ikarus_text_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
IkarusErrorData * error_out
) {
return ikarus::util::create_property<IkarusTextProperty>(project, name, property_source, error_out);
}
IkarusTextValue * ikarus_text_property_get_default_value(IkarusTextProperty * property, IkarusErrorData * error_out) {
return ikarus::util::get_default_value<IkarusTextProperty>(property, error_out);
}
void ikarus_text_property_set_default_value(
IkarusTextProperty * property,
IkarusTextValue * new_default_value,
IkarusErrorData * error_out
) {
ikarus::util::set_default_value<IkarusTextProperty>(property, new_default_value, error_out);
}

11
src/objects/properties/text_property.hpp
View file

@ -1,8 +1,15 @@
#pragma once #pragma once
#include <objects/properties/property.hpp> #include <ikarus/objects/properties/property_type.h>
#include <objects/properties/property.hpp>
#include <values/text_value.hpp>
struct IkarusTextProperty : IkarusProperty {
public:
using value_type = IkarusTextValue;
constexpr auto static PropertyType = IkarusPropertyType_Text;
struct IkarusTextProperty final : IkarusProperty {
public: public:
IkarusTextProperty(struct IkarusProject * project, IkarusId id); IkarusTextProperty(struct IkarusProject * project, IkarusId id);
}; };

30
src/objects/properties/toggle_property.cpp
View file

@ -1,7 +1,33 @@
#include "toggle_property.hpp" #include "toggle_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <objects/properties/property_source.hpp>
#include <objects/properties/util.hpp>
#include <values/value.hpp>
IkarusToggleProperty::IkarusToggleProperty(IkarusProject * project, IkarusId id): IkarusToggleProperty::IkarusToggleProperty(IkarusProject * project, IkarusId id):
IkarusProperty{project, id, this} {} IkarusProperty{project, id, this} {}
IkarusToggleProperty * IkarusToggleProperty * ikarus_toggle_property_create(
ikarus_toggle_property_create(struct IkarusProject * project, char const * name, struct IkarusPropertySource * property_source) {} struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
IkarusErrorData * error_out
) {
return ikarus::util::create_property<IkarusToggleProperty>(project, name, property_source, error_out);
}
IkarusToggleValue * ikarus_toggle_property_get_default_value(struct IkarusToggleProperty * property, IkarusErrorData * error_out) {
return ikarus::util::get_default_value<IkarusToggleProperty>(property, error_out);
}
void ikarus_toggle_property_set_default_value(
struct IkarusToggleProperty * property,
struct IkarusToggleValue * new_default_value,
IkarusErrorData * error_out
) {
ikarus::util::set_default_value<IkarusToggleProperty>(property, new_default_value, error_out);
}

7
src/objects/properties/toggle_property.hpp
View file

@ -1,8 +1,15 @@
#pragma once #pragma once
#include <ikarus/objects/properties/property_type.h>
#include <objects/properties/property.hpp> #include <objects/properties/property.hpp>
#include <values/toggle_value.hpp>
struct IkarusToggleProperty : IkarusProperty { struct IkarusToggleProperty : IkarusProperty {
public:
using value_type = IkarusToggleValue;
constexpr auto static PropertyType = IkarusPropertyType_Toggle;
public: public:
IkarusToggleProperty(struct IkarusProject * project, IkarusId id); IkarusToggleProperty(struct IkarusProject * project, IkarusId id);
}; };

100
src/objects/properties/util.hpp Normal file
View file

@ -0,0 +1,100 @@
#pragma once
#include <boost/type_index.hpp>
#include <cppbase/strings.hpp>
#include <ikarus/objects/properties/property.h>
#include <errors.hpp>
#include <objects/properties/property.hpp>
#include <objects/properties/property_source.hpp>
#include <persistence/project.hpp>
#include <values/value.hpp>
namespace ikarus::util {
template<typename T>
T * create_property(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF_NULL(property_source, nullptr);
IKARUS_FAIL_IF(
cppbase::is_empty_or_blank(name),
nullptr,
fmt::format("{} name cannot be empty or blank", boost::typeindex::type_id<T>().pretty_name()),
IkarusErrorInfo_Client_InvalidInput
)
IKARUS_VTRYRV_OR_FAIL(
IkarusId const id,
nullptr,
"failed to create property: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->transact([name, property_source](auto * db) -> cppbase::Result<IkarusId, sqlitecpp::TransactionError> {
TRY(db->execute("INSERT INTO `objects`(`type`, `name`) VALUES(?, ?, ?)", IkarusObjectType_Property, name));
auto id = ikarus_id_from_data_and_type(db->last_insert_rowid(), IkarusObjectType_Property);
TRY(db->execute(
"INSERT INTO `properties`(`id`, `type`, `source`) VALUES(?, ?, ?)",
id,
T::PropertyType,
property_source->get_id()
));
return cppbase::ok(id);
})
);
auto * ret = dynamic_cast<T *>(project->get_property(id, T::PropertyType));
IKARUS_FAIL_IF(
ret == nullptr,
nullptr,
fmt::format("created {} cannot be casted down from IkarusProject", boost::typeindex::type_id<T>().pretty_name()),
IkarusErrorInfo_LibIkarus_InvalidState
);
return ret;
}
template<typename T>
typename T::value_type * get_default_value(IkarusProperty const * property, IkarusErrorData * error_out) {
auto * value = ikarus_property_get_default_value(property, error_out);
IKARUS_FAIL_IF_ERROR(nullptr);
auto * ret = boost::variant2::get_if<typename T::value_type *>(&value->data);
IKARUS_FAIL_IF(
ret == nullptr,
nullptr,
fmt::format(
"{} default value is not a(n) {}",
boost::typeindex::type_id<T>().pretty_name(),
boost::typeindex::type_id<typename T::value_type>().pretty_name()
),
IkarusErrorInfo_Database_InvalidState
);
return *ret;
}
template<typename T>
void set_default_value(T * property, typename T::value_type * new_default_value, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
IKARUS_FAIL_IF_NULL(new_default_value, );
auto value_json_str = boost::json::serialize(new_default_value->to_json());
IKARUS_TRYRV_OR_FAIL(
,
"unable to set property default value: {}",
IkarusErrorInfo_Database_QueryFailed,
property->project->db->execute("UPDATE `properties` SET `default_value` = ? WHERE `id` = ?", value_json_str, property->id)
);
}
} // namespace ikarus::util

40
src/persistence/migrations.hpp Normal file
View file

@ -0,0 +1,40 @@
#pragma once
#include <array>
#include <cppbase/assets.hpp>
#include <cppbase/result.hpp>
#include <sqlitecpp/connection.hpp>
namespace ikarus {
CPPBASE_ASSET(m1_initial_layout, "persistence/migrations/m1_initial_layout.sql");
class Migration : public sqlitecpp::Migration {
public:
Migration(char const * sql, size_t size):
sql{sql, size} {}
~Migration() override = default;
public:
[[nodiscard]] inline auto get_content() const -> std::string_view override {
return sql;
}
public:
std::string_view sql;
};
#define DECLARE_MIGRATION(name) std::make_unique<ikarus::Migration>(static_cast<char const *>(name()), name##_size())
constexpr std::string_view DB_VERSION_KEY = "IKARUS_DB_VERSION";
std::vector<std::unique_ptr<sqlitecpp::Migration>> const MIGRATIONS = []() {
std::vector<std::unique_ptr<sqlitecpp::Migration>> ret;
ret.emplace_back(DECLARE_MIGRATION(m1_initial_layout));
return ret;
}();
} // namespace ikarus

7
src/persistence/migrations/m0_genesis.sql Normal file
View file

@ -0,0 +1,7 @@
CREATE TABLE `metadata`
(
`key` VARCHAR(255) NOT NULL,
`value` VARCHAR(255) NOT NULL,
PRIMARY KEY (`key`)
)

233
src/persistence/project.cpp
View file

@ -1,6 +1,12 @@
#include "project.hpp" #include "project.hpp"
#include "ikarus/persistence/project.h" #include "migrations.hpp"
#include <boost/filesystem.hpp>
#include <cppbase/strings.hpp>
#include <ikarus/persistence/project.h>
#include <objects/blueprint.hpp> #include <objects/blueprint.hpp>
#include <objects/entity.hpp> #include <objects/entity.hpp>
@ -9,10 +15,10 @@
#include <objects/properties/text_property.hpp> #include <objects/properties/text_property.hpp>
#include <objects/properties/toggle_property.hpp> #include <objects/properties/toggle_property.hpp>
IkarusProject::IkarusProject(std::string_view name, std::filesystem::path path): IkarusProject::IkarusProject(std::string_view name, std::string_view path, std::unique_ptr<sqlitecpp::Connection> && db):
name{name}, name{name},
path{path}, path{std::move(path)},
db{nullptr}, db{std::move(db)},
_blueprints{}, _blueprints{},
_properties{}, _properties{},
_entities{} {} _entities{} {}
@ -52,3 +58,222 @@ auto IkarusProject::get_property(IkarusId id, IkarusPropertyType type) -> Ikarus
auto IkarusProject::uncache(IkarusProperty * property) -> void { auto IkarusProject::uncache(IkarusProperty * property) -> void {
remove_cached_object(property, _properties); remove_cached_object(property, _properties);
} }
IkarusProject * ikarus_project_create(char const * path, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(path, nullptr);
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(path), nullptr, "path must not be empty", IkarusErrorInfo_Client_InvalidInput);
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(name), nullptr, "name must not be empty", IkarusErrorInfo_Client_InvalidInput);
boost::filesystem::path fs_path{path};
{
boost::system::error_code ec;
bool const exists = fs::exists(fs_path, ec);
IKARUS_FAIL_IF(ec, nullptr, "unable to check whether path is occupied", IkarusErrorInfo_Filesystem_AlreadyExists);
IKARUS_FAIL_IF(exists, nullptr, "path is already occupied", IkarusErrorInfo_Filesystem_AlreadyExists);
}
IKARUS_VTRYRV_OR_FAIL(
auto db,
nullptr,
"failed to create project db: {}",
IkarusErrorInfo_Database_ConnectionFailed,
sqlitecpp::Connection::open(path)
);
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to migrate project db: {}",
IkarusErrorInfo_Database_MigrationFailed,
db->migrate(ikarus::MIGRATIONS)
);
if (auto res = db->execute("INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)", DB_PROJECT_NAME_KEY, name); res.is_error()) {
boost::system::error_code ec;
fs::remove(fs_path, ec);
IKARUS_FAIL_IF(
ec,
nullptr,
"failed to remove project db after being unable to insert name into metadata table: {}",
IkarusErrorInfo_Filesystem_AccessIssue
);
IKARUS_FAIL(nullptr, "failed to insert project name into metadata: {}", IkarusErrorInfo_Database_QueryFailed);
}
return new IkarusProject{name, path, std::move(db)};
}
IkarusProject * ikarus_project_create_in_memory(char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(name), nullptr, "name must not be empty", IkarusErrorInfo_Client_InvalidInput);
IKARUS_VTRYRV_OR_FAIL(
auto db,
nullptr,
"failed to create project db in memory: {}",
IkarusErrorInfo_Database_ConnectionFailed,
sqlitecpp::Connection::open_in_memory()
);
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to migrate project db: {}",
IkarusErrorInfo_Database_MigrationFailed,
db->migrate(ikarus::MIGRATIONS)
);
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to insert project name into metadata: {}",
IkarusErrorInfo_Database_QueryFailed,
db->execute("INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)", DB_PROJECT_NAME_KEY, name)
);
return new IkarusProject{name, ":memory:", std::move(db)};
}
IkarusProject * ikarus_project_open(char const * path, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(path, nullptr);
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(path), nullptr, "path must not be empty", IkarusErrorInfo_Client_InvalidInput);
IKARUS_VTRYRV_OR_FAIL(
auto db,
nullptr,
"failed to open project db: {}",
IkarusErrorInfo_Database_ConnectionFailed,
sqlitecpp::Connection::open(path)
);
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to migrate project db: {}",
IkarusErrorInfo_Database_MigrationFailed,
db->migrate(ikarus::MIGRATIONS)
);
IKARUS_VTRYRV_OR_FAIL(
auto const & name,
nullptr,
"failed to retrieve project name from metadata: {}",
IkarusErrorInfo_Database_QueryFailed,
db->query_one<std::string>("SELECT `value` FROM `metadata` WHERE `key` = ?", DB_PROJECT_NAME_KEY)
);
return new IkarusProject{name, path, std::move(db)};
}
char const * ikarus_project_get_name(IkarusProject const * project, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
return project->name.data();
}
void ikarus_project_set_name(IkarusProject * project, char const * new_name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(new_name, );
IKARUS_FAIL_IF(cppbase::is_empty_or_blank(new_name), , "name must not be empty", IkarusErrorInfo_Client_InvalidInput);
IKARUS_TRYRV_OR_FAIL(
,
"failed to update project name: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->execute("UPDATE `metadata` SET `value` = ? WHERE `key` = ?", new_name, DB_PROJECT_NAME_KEY)
);
}
char const * ikarus_project_get_path(IkarusProject const * project, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
return project->path.data();
}
// these take a mutable project right now because the get_cached-* function must be mutable
// since we insert a backreference to the project into the objects, not ideal,
// but fine for now since "mutability" is a vague concept for projects anyway
void ikarus_project_get_blueprints(
IkarusProject * project,
struct IkarusBlueprint ** blueprints_out,
size_t blueprints_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(blueprints_out, );
if (blueprints_out_size == 0) {
return;
}
IkarusId ids[blueprints_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch project blueprints from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_many_buffered<IkarusId>("SELECT `id` FROM `blueprints`", ids, blueprints_out_size)
);
for (size_t i = 0; i < blueprints_out_size; ++i) {
blueprints_out[i] = project->get_blueprint(ids[i]);
}
}
size_t ikarus_project_get_blueprint_count(IkarusProject const * project, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, 0);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
0,
"unable to fetch project blueprint count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_one<int64_t>("SELECT COUNT(*) FROM `blueprints`")
);
return ret;
}
void ikarus_project_get_entities(
IkarusProject * project,
struct IkarusEntity ** entities_out,
size_t entities_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(entities_out, );
if (entities_out_size == 0) {
return;
}
IkarusId ids[entities_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch project entities from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_many_buffered<IkarusId>("SELECT `id` FROM `entities`", ids, entities_out_size)
);
for (size_t i = 0; i < entities_out_size; ++i) {
entities_out[i] = project->get_entity(ids[i]);
}
}
size_t ikarus_project_get_entity_count(IkarusProject * project, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, 0);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
0,
"unable to fetch project entity count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_one<int64_t>("SELECT COUNT(*) FROM `entities`")
);
return ret;
}

18
src/persistence/project.hpp
View file

@ -1,20 +1,23 @@
#pragma once #pragma once
#include <filesystem>
#include <ranges> #include <ranges>
#include <stack> #include <stack>
#include <string> #include <string>
#include <boost/filesystem.hpp>
#include <sqlitecpp/connection.hpp> #include <sqlitecpp/connection.hpp>
#include <ikarus/errors.h> #include <ikarus/errors.h>
#include <ikarus/id.h> #include <ikarus/id.h>
#include <ikarus/objects/properties/property_type.h> #include <ikarus/objects/properties/property_type.h>
namespace fs = boost::filesystem;
/// \private /// \private
struct IkarusProject { struct IkarusProject {
public: public:
IkarusProject(std::string_view name, std::filesystem::path path); IkarusProject(std::string_view name, std::string_view path, std::unique_ptr<sqlitecpp::Connection> && db);
public: public:
[[nodiscard]] auto get_blueprint(IkarusId id) -> struct IkarusBlueprint *; [[nodiscard]] auto get_blueprint(IkarusId id) -> struct IkarusBlueprint *;
@ -23,6 +26,7 @@ public:
[[nodiscard]] auto get_entity(IkarusId id) -> struct IkarusEntity *; [[nodiscard]] auto get_entity(IkarusId id) -> struct IkarusEntity *;
auto uncache(struct IkarusEntity * entity) -> void; auto uncache(struct IkarusEntity * entity) -> void;
// TODO improve this to take a template param so that we don't have to cast in e.g. ikarus_toggle_property_create
[[nodiscard]] auto get_property(IkarusId id, IkarusPropertyType type) -> struct IkarusProperty *; [[nodiscard]] auto get_property(IkarusId id, IkarusPropertyType type) -> struct IkarusProperty *;
auto uncache(struct IkarusProperty * property) -> void; auto uncache(struct IkarusProperty * property) -> void;
@ -45,11 +49,13 @@ private:
public: public:
std::string name; std::string name;
std::filesystem::path path; std::string_view path;
std::unique_ptr<sqlitecpp::Connection> db; std::unique_ptr<sqlitecpp::Connection> db;
private: private:
std::unordered_map<IkarusId, std::unique_ptr<struct IkarusBlueprint>> _blueprints; std::unordered_map<IkarusId, std::unique_ptr<struct IkarusBlueprint>> mutable _blueprints;
std::unordered_map<IkarusId, std::unique_ptr<struct IkarusProperty>> _properties; std::unordered_map<IkarusId, std::unique_ptr<struct IkarusProperty>> mutable _properties;
std::unordered_map<IkarusId, std::unique_ptr<struct IkarusEntity>> _entities; std::unordered_map<IkarusId, std::unique_ptr<struct IkarusEntity>> mutable _entities;
}; };
constexpr std::string_view DB_PROJECT_NAME_KEY = "PROJECT_NAME";

21
src/values/entity_property_value.cpp Normal file
View file

@ -0,0 +1,21 @@
#include "values/entity_property_value.hpp"
#include <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;
}

7
src/values/entity_property_value.hpp Normal file
View file

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

2
src/values/value.cpp
View file

@ -19,7 +19,7 @@
IkarusValue::IkarusValue(Data data): IkarusValue::IkarusValue(Data data):
data(data) {} data(data) {}
cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_json(boost::json::value const & json) { cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_json(boost::json::value json) {
if (auto const * obj = json.if_object(); obj == nullptr) { if (auto const * obj = json.if_object(); obj == nullptr) {
return cppbase::err(FromJsonError{}); return cppbase::err(FromJsonError{});
} else { } else {

46
src/values/value.hpp
View file

@ -5,6 +5,9 @@
#include <cppbase/result.hpp> #include <cppbase/result.hpp>
#include <errors.hpp>
#include <persistence/project.hpp>
struct IkarusValue { struct IkarusValue {
public: public:
using Data = boost::variant2::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>; using Data = boost::variant2::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>;
@ -24,9 +27,50 @@ public:
public: public:
struct FromJsonError {}; struct FromJsonError {};
[[nodiscard]] static cppbase::Result<IkarusValue *, FromJsonError> from_json(boost::json::value const & json); [[nodiscard]] static cppbase::Result<IkarusValue *, FromJsonError> from_json(boost::json::value json);
[[nodiscard]] boost::json::value to_json() const; [[nodiscard]] boost::json::value to_json() const;
public: public:
Data data; 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;
}

2
vendor/sqlitecpp vendored

@ -1 +1 @@
Subproject commit 00a1afcc5f564f562c436f1ddfa4f44bb6489b17 Subproject commit e837d64405fb43adefe03994837f5ed5793138c5