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

finalize schema/data setup

Browse source 
Signed-off-by: Folling <mail@folling.io>
This commit is contained in:
folling 2025-01-01 13:49:05 +01:00 • committed by Folling
parent 4d7bf09c4e
commit 954b8a11a3
Signed by: folling
SSH key fingerprint: SHA256:S9qEx5WCFFLK49tE/LKnKuJYM5sw+++Dn6qJbbyxnCY
89 changed files with 2324 additions and 6271 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.clang-format
View file

@ -109,7 +109,9 @@ IncludeCategories:
Priority: 11
- Regex: '^<sqlitecpp/.*>$'
Priority: 12
- Regex: '^<ikarus/.*>$'
- Regex: '^<ikarus/.*\.h>$'
Priority: 13
- Regex: '^<ikarus/.*\.hpp>$'
Priority: 13
IndentAccessModifiers: false
@ -189,4 +191,4 @@ SpacesInSquareBrackets: false
Standard: c++20
TabWidth: 4
UseTab: Never
UseTab: Always

3
.gitmodules vendored
View file

@ -10,3 +10,6 @@
[submodule "vendor/cppbase"]
path = vendor/cppbase
url = ssh://git@git.rewritesarebliss.com:16658/Folling/cppbase.git
[submodule "vendor/json"]
path = vendor/json
url = git@github.com:nlohmann/json.git

27
CMakeLists.txt
View file

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.18)
cmake_minimum_required(VERSION 3.31)
project(ikarus)
option(LIBIKARUS_ENABLE_TESTS "Enable tests" OFF)
@ -9,7 +9,7 @@ add_subdirectory(vendor)
add_subdirectory(include)
add_subdirectory(src)
find_package(Boost COMPONENTS system filesystem REQUIRED)
find_package(Boost CONFIG COMPONENTS system filesystem REQUIRED)
add_library(
ikarus SHARED
@ -17,40 +17,31 @@ add_library(
${SOURCE_FILES}
)
add_dependencies(
ikarus
flatbuffer_headers
)
set_target_properties(
ikarus PROPERTIES
CXX_STANDARD 23
CXX_STANDARD_REQUIRED ON
LINKER_LANGUAGE CXX
POSITION_INDEPENDENT_CODE TRUE
)
target_include_directories(
ikarus PUBLIC
ikarus
PUBLIC
${CMAKE_CURRENT_LIST_DIR}/include
)
target_include_directories(
ikarus PRIVATE
PRIVATE
${CMAKE_CURRENT_LIST_DIR}/src
${Boost_INCLUDE_DIR}
)
target_link_libraries(
ikarus PRIVATE
cppbase
sqlitecpp
nlohmann_json::nlohmann_json
${Boost_LIBRARIES}
)
target_include_directories(
ikarus PRIVATE
${Boost_INCLUDE_DIR}
)
if (LIBIKARUS_ENABLE_LINTS)
find_program(IWYU_PATH NAMES include-what-you-use iwyu REQUIRED)
find_program(CLANG_TIDY_PATH NAMES clang-tidy REQUIRED)
@ -66,7 +57,7 @@ if (LIBIKARUS_BUILD_DOCS)
find_program(DOXYGEN_PATH NAMES doxygen REQUIRED)
add_custom_target(
libikarus_docs
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/docs
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/docs/doxygen
COMMAND ${DOXYGEN_PATH} DoxyFile
COMMENT "Generating documentation with Doxygen"
VERBATIM

35
CMakePresets.json Normal file
View file

@ -0,0 +1,35 @@
{
"version": 6,
"cmakeMinimumRequired": {
"major": 3,
"minor": 23,
"patch": 0
},
"configurePresets": [
{
"name": "default-mac",
"displayName": "Default Config for MacOS",
"description": "Default MacOS build using Ninja generator",
"generator": "Ninja",
"binaryDir": "${sourceDir}/build/default",
"cacheVariables": {
"CMAKE_COLOR_DIAGNOSTICS": "ON",
"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
},
"toolchainFile": "tools/cmake/toolchains/mac.cmake"
},
{
"name": "test-mac",
"displayName": "Test Config MacOS",
"description": "Test MacOS build using Ninja generator",
"generator": "Ninja",
"binaryDir": "${sourceDir}/build/test",
"cacheVariables": {
"CMAKE_COLOR_DIAGNOSTICS": "ON",
"LIBIKARUS_ENABLE_TESTS": "ON",
"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
},
"toolchainFile": "tools/cmake/toolchains/mac.cmake"
}
]
}

2
LICENSE.md
View file

@ -1,4 +1,4 @@
Copyright 2019-2023 Folling (folling@ikarus.world)
Copyright 2019-2024 Folling (mail@folling.io)
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
following conditions are met:

5
docs/Flags.md Normal file
View file

@ -0,0 +1,5 @@
All mutating functions take a flag argument that can be used to control the behavior of the function. The flags are
defined in a corresponding enum. The flags are passed as a bitset, so multiple flags can be passed at once by using the
bitwise OR operator `|`.
The reason for this feature is ABI stability.

7
docs/Ownership.md Normal file
View file

@ -0,0 +1,7 @@
### Getters
Returned data remains owned by libikarus, the exception are Entity(Property)Values.
### Setters
libikarus assumes ownership of any data passed into it, the exception are Entity(Property)Values.

0
docs/DoxyFile → docs/doxygen/DoxyFile
View file

0
docs/format_fix.js → docs/doxygen/format_fix.js
View file

0
docs/header.html → docs/doxygen/header.html
View file

2
docs/internal/Caching.md Normal file
View file

@ -0,0 +1,2 @@
libikarus doesn't perform any caching as the filesystem & SQLite already cache quite well.
Until we can see that there's a performance overhead no caching will be implemented.

2
include/CMakeLists.txt
View file

@ -5,5 +5,3 @@ file(
)
set(INCLUDE_FILES ${FILES} PARENT_SCOPE)
add_subdirectory(ikarus)

1
include/ikarus/CMakeLists.txt
View file

@ -1 +0,0 @@
add_subdirectory(models)

54
include/ikarus/errors.h
View file

@ -1,19 +1,17 @@
#pragma once
/// \file errors.h
/// \author Folling <folling@ikarus.world>
/// \author Folling <mail@folling.io>
#include <ikarus/macros.h>
/// \addtogroup errors Errors
/// \brief Error handling within libikarus
/// \details Functions in Ikarus may fail. To report the type of failure all functions have an out parameter for the error.
/// Upon erring the function will store relevant information about the error in the out parameter.
/// If the out parameter is null nothing will be stored. This is not recommended as it essentially ignores errors.
/// For the sake of simplicity we have avoided mechanisms that "force" clients to handle errors.
/// Note that Ikarus does not check for null pointers. Passing null pointers to functions that do not explicitly state that they accept null
/// pointers is undefined behaviour. This decision is done for the sake of brevity and readability. `project_get_name(project)` is also
/// synonymous to `project->get_name()` in OOP languages, which shares the same semantics.
/// Upon erring the function will store relevant information about the error in
/// the out parameter. If the out parameter is null nothing will be stored. This
/// is not recommended as it essentially ignores errors. For the sake of
/// simplicity we have avoided mechanisms that "force" clients to handle errors.
/// @{
IKARUS_BEGIN_HEADER
@ -30,37 +28,40 @@ enum IkarusErrorInfo {
/// \brief The client provided a null value for a parameter that must not be null.
/// Example: Passing null for `ikarus_project_get_name`
IkarusErrorInfo_Client_InvalidNull = 0x01000002,
/// \brief The client provided a non-existent resource.
/// Example: Passing an entity to a function after it has been deleted.
IkarusErrorInfo_Client_NonExistent = 0x01000003,
/// \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.
IkarusErrorInfo_Client_IndexOutOfBounds = 0x01000003,
IkarusErrorInfo_Client_IndexOutOfBounds = 0x01000004,
/// \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).
IkarusErrorInfo_Client_ValueOutOfBounds = 0x01000004,
IkarusErrorInfo_Client_ValueOutOfBounds = 0x01000005,
/// \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.
IkarusErrorInfo_Client_InvalidInput = 0x01000005,
/// Example: Passing an empty/blank string for a string that must be
/// non-empty/-blank.
IkarusErrorInfo_Client_InvalidInput = 0x01000006,
/// \brief The client provided valid data in an invalid format.
/// Example: Passing a malformed JSON string.
IkarusErrorInfo_Client_InvalidFormat = 0x01000006,
IkarusErrorInfo_Client_InvalidFormat = 0x01000007,
/// \brief The client violated a constraint.
/// \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.
IkarusErrorInfo_Client_ConstraintViolated = 0x10000007,
/// \details This error is most likely caused by clients.
/// Example: A user tries to set the age of a character to a value outside
/// its specified range.
IkarusErrorInfo_Client_ConstraintViolated = 0x10000008,
// 0x02 reserved for dependency errors
/// \brief A file or directory already exists.
IkarusErrorInfo_Filesystem_AccessIssue = 0x03000001,
/// \brief A file was not found.
IkarusErrorInfo_Filesystem_NotFound = 0x03000002,
IkarusErrorInfo_Filesystem_NotFound = 0x03000001,
/// \brief A file or directory already exists.
IkarusErrorInfo_Filesystem_AlreadyExists = 0x03000003,
IkarusErrorInfo_Filesystem_AlreadyExists = 0x03000002,
/// \brief Missing permissions to access a file or directory.
IkarusErrorInfo_Filesystem_MissingPermissions = 0x03000004,
IkarusErrorInfo_Filesystem_MissingPermissions = 0x03000003,
/// \brief Insufficient space to perform an operation.
IkarusErrorInfo_Filesystem_InsufficientSpace = 0x03000005,
IkarusErrorInfo_Filesystem_InsufficientSpace = 0x03000004,
/// \brief A path is invalid.
IkarusErrorInfo_Filesystem_InvalidPath = 0x03000006,
IkarusErrorInfo_Filesystem_InvalidPath = 0x03000005,
/// \brief A database connection failed.
IkarusErrorInfo_Database_ConnectionFailed = 0x04000001,
@ -69,7 +70,7 @@ enum IkarusErrorInfo {
/// \brief A database migration failed.
IkarusErrorInfo_Database_MigrationFailed = 0x04000003,
/// \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-existent blueprint.
IkarusErrorInfo_Database_InvalidState = 0x04000004,
/// \brief A system call failed.
@ -81,7 +82,8 @@ enum IkarusErrorInfo {
/// \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.
/// 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.
IkarusErrorInfo_LibIkarus_InvalidState = 0x06000001,
/// \brief libikarus is unable to perform a certain operation that should succeed.
@ -97,7 +99,7 @@ enum IkarusErrorInfo {
/// \brief The data stored for an error
struct IkarusErrorData {
/// \brief The error type
IkarusErrorInfo info;
enum IkarusErrorInfo info;
char message[IKARUS_ERROR_DATA_MAX_MESSAGE_LIMIT];
};
@ -106,7 +108,7 @@ struct IkarusErrorData {
/// \param info The error info to get the name of.
/// \return The name of the error info.
/// \remark The returned pointer is valid for the lifetime of the program and must not be freed.
IKA_API char const * ikarus_get_error_info_name(IkarusErrorInfo info);
IKA_API char const * ikarus_error_info_get_name(enum IkarusErrorInfo info);
/// \brief Checks if an error data is a success.
/// \param data The error data to check.

41
include/ikarus/models/CMakeLists.txt
View file

@ -1,41 +0,0 @@
file(
GLOB_RECURSE
FLATBUFFER_SOURCES
"*.fbs"
)
foreach (FLATBUFFER_SOURCE IN LISTS ${FLATBUFFER_SOURCES})
cmake_path(
GET
${FLATBUFFER_SOURCE}
FILENAME
FLATBUFFER_SOURCE_NAME
)
string(
CONCAT
FLATBUFFER_GENERATED_SOURCE_NAME
${FLATBUFFER_SOURCE_NAME}
"_generated"
)
cmake_path(
REPLACE_EXTENSION
${FLATBUFFER_GENERATED_SOURCE_NAME}
".h"
OUTPUT_VARIABLE
FLATBUFFER_GENERATED_HEADER
)
list(APPEND FLATBUFFER_GENERATED_HEADERS ${FLATBUFFER_GENERATED_HEADER})
endforeach ()
add_custom_target(
flatbuffer_headers
COMMENT "Generating flatbuffer headers"
DEPENDS ${FLATBUFFER_SOURCES}
BYPRODUCTS ${FLATBUFFER_GENERATED_HEADERS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMAND flatc --cpp --cpp-std "c++17" ${FLATBUFFER_SOURCES}
VERBATIM
)

12
include/ikarus/models/blueprint.fbs
View file

@ -1,12 +0,0 @@
include "property.fbs";
namespace Ikarus;
table Blueprint {
id: int64;
name: string;
description: string;
tags: [string];
}
root_type Blueprint;

153
include/ikarus/models/blueprint_generated.h
View file

@ -1,153 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_BLUEPRINT_IKARUS_H_
#define FLATBUFFERS_GENERATED_BLUEPRINT_IKARUS_H_
#include "flatbuffers/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
FLATBUFFERS_VERSION_MINOR == 3 &&
FLATBUFFERS_VERSION_REVISION == 25,
"Non-compatible flatbuffers version included");
#include "property_generated.h"
namespace Ikarus {
struct Blueprint;
struct BlueprintBuilder;
struct Blueprint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BlueprintBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_NAME = 6,
VT_DESCRIPTION = 8,
VT_TAGS = 10
};
int64_t id() const {
return GetField<int64_t>(VT_ID, 0);
}
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
const ::flatbuffers::String *description() const {
return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_ID, 8) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_DESCRIPTION) &&
verifier.VerifyString(description()) &&
VerifyOffset(verifier, VT_TAGS) &&
verifier.VerifyVector(tags()) &&
verifier.VerifyVectorOfStrings(tags()) &&
verifier.EndTable();
}
};
struct BlueprintBuilder {
typedef Blueprint Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(int64_t id) {
fbb_.AddElement<int64_t>(Blueprint::VT_ID, id, 0);
}
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Blueprint::VT_NAME, name);
}
void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
fbb_.AddOffset(Blueprint::VT_DESCRIPTION, description);
}
void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
fbb_.AddOffset(Blueprint::VT_TAGS, tags);
}
explicit BlueprintBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Blueprint> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Blueprint>(end);
return o;
}
};
inline ::flatbuffers::Offset<Blueprint> CreateBlueprint(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
::flatbuffers::Offset<::flatbuffers::String> name = 0,
::flatbuffers::Offset<::flatbuffers::String> description = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0) {
BlueprintBuilder builder_(_fbb);
builder_.add_id(id);
builder_.add_tags(tags);
builder_.add_description(description);
builder_.add_name(name);
return builder_.Finish();
}
struct Blueprint::Traits {
using type = Blueprint;
static auto constexpr Create = CreateBlueprint;
};
inline ::flatbuffers::Offset<Blueprint> CreateBlueprintDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
const char *name = nullptr,
const char *description = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto description__ = description ? _fbb.CreateString(description) : 0;
auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
return Ikarus::CreateBlueprint(
_fbb,
id,
name__,
description__,
tags__);
}
inline const Ikarus::Blueprint *GetBlueprint(const void *buf) {
return ::flatbuffers::GetRoot<Ikarus::Blueprint>(buf);
}
inline const Ikarus::Blueprint *GetSizePrefixedBlueprint(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Ikarus::Blueprint>(buf);
}
inline bool VerifyBlueprintBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Ikarus::Blueprint>(nullptr);
}
inline bool VerifySizePrefixedBlueprintBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Ikarus::Blueprint>(nullptr);
}
inline void FinishBlueprintBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Blueprint> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedBlueprintBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Blueprint> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Ikarus
#endif // FLATBUFFERS_GENERATED_BLUEPRINT_IKARUS_H_

26
include/ikarus/models/entity.fbs
View file

@ -1,26 +0,0 @@
include "value.fbs";
include "property.fbs";
include "blueprint.fbs";
namespace Ikarus;
table NamedValue {
name: string (key);
value: Ikarus.Value.Value;
}
table PropertyValue {
property_id: int64 (key);
data: Ikarus.Value.Data;
}
table Entity {
id: int64;
name: string;
description: string;
tags: [string];
values: [NamedValue];
property_values: [PropertyValue];
}
root_type Entity;

398
include/ikarus/models/entity_generated.h
View file

@ -1,398 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_ENTITY_IKARUS_H_
#define FLATBUFFERS_GENERATED_ENTITY_IKARUS_H_
#include "flatbuffers/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
FLATBUFFERS_VERSION_MINOR == 3 &&
FLATBUFFERS_VERSION_REVISION == 25,
"Non-compatible flatbuffers version included");
#include "blueprint_generated.h"
#include "property_generated.h"
#include "value_generated.h"
namespace Ikarus {
struct NamedValue;
struct NamedValueBuilder;
struct PropertyValue;
struct PropertyValueBuilder;
struct Entity;
struct EntityBuilder;
struct NamedValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef NamedValueBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_VALUE = 6
};
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
bool KeyCompareLessThan(const NamedValue * const o) const {
return *name() < *o->name();
}
int KeyCompareWithValue(const char *_name) const {
return strcmp(name()->c_str(), _name);
}
template<typename StringType>
int KeyCompareWithValue(const StringType& _name) const {
if (name()->c_str() < _name) return -1;
if (_name < name()->c_str()) return 1;
return 0;
}
const Ikarus::Value::Value *value() const {
return GetPointer<const Ikarus::Value::Value *>(VT_VALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_VALUE) &&
verifier.VerifyTable(value()) &&
verifier.EndTable();
}
};
struct NamedValueBuilder {
typedef NamedValue Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(NamedValue::VT_NAME, name);
}
void add_value(::flatbuffers::Offset<Ikarus::Value::Value> value) {
fbb_.AddOffset(NamedValue::VT_VALUE, value);
}
explicit NamedValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<NamedValue> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<NamedValue>(end);
fbb_.Required(o, NamedValue::VT_NAME);
return o;
}
};
inline ::flatbuffers::Offset<NamedValue> CreateNamedValue(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> name = 0,
::flatbuffers::Offset<Ikarus::Value::Value> value = 0) {
NamedValueBuilder builder_(_fbb);
builder_.add_value(value);
builder_.add_name(name);
return builder_.Finish();
}
struct NamedValue::Traits {
using type = NamedValue;
static auto constexpr Create = CreateNamedValue;
};
inline ::flatbuffers::Offset<NamedValue> CreateNamedValueDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr,
::flatbuffers::Offset<Ikarus::Value::Value> value = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
return Ikarus::CreateNamedValue(
_fbb,
name__,
value);
}
struct PropertyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef PropertyValueBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PROPERTY_ID = 4,
VT_DATA_TYPE = 6,
VT_DATA = 8
};
int64_t property_id() const {
return GetField<int64_t>(VT_PROPERTY_ID, 0);
}
bool KeyCompareLessThan(const PropertyValue * const o) const {
return property_id() < o->property_id();
}
int KeyCompareWithValue(int64_t _property_id) const {
return static_cast<int>(property_id() > _property_id) - static_cast<int>(property_id() < _property_id);
}
Ikarus::Value::Data data_type() const {
return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DATA_TYPE, 0));
}
const void *data() const {
return GetPointer<const void *>(VT_DATA);
}
template<typename T> const T *data_as() const;
const Ikarus::Value::ToggleDataPoint *data_as_ToggleDataPoint() const {
return data_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(data()) : nullptr;
}
const Ikarus::Value::NumberDataPoint *data_as_NumberDataPoint() const {
return data_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(data()) : nullptr;
}
const Ikarus::Value::TextDataPoint *data_as_TextDataPoint() const {
return data_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(data()) : nullptr;
}
const Ikarus::Value::SimpleData *data_as_SimpleData() const {
return data_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(data()) : nullptr;
}
const Ikarus::Value::CombinedData *data_as_CombinedData() const {
return data_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(data()) : nullptr;
}
const Ikarus::Value::ListData *data_as_ListData() const {
return data_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(data()) : nullptr;
}
const Ikarus::Value::ComplexData *data_as_ComplexData() const {
return data_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(data()) : nullptr;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_PROPERTY_ID, 8) &&
VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
VerifyOffset(verifier, VT_DATA) &&
VerifyData(verifier, data(), data_type()) &&
verifier.EndTable();
}
};
template<> inline const Ikarus::Value::ToggleDataPoint *PropertyValue::data_as<Ikarus::Value::ToggleDataPoint>() const {
return data_as_ToggleDataPoint();
}
template<> inline const Ikarus::Value::NumberDataPoint *PropertyValue::data_as<Ikarus::Value::NumberDataPoint>() const {
return data_as_NumberDataPoint();
}
template<> inline const Ikarus::Value::TextDataPoint *PropertyValue::data_as<Ikarus::Value::TextDataPoint>() const {
return data_as_TextDataPoint();
}
template<> inline const Ikarus::Value::SimpleData *PropertyValue::data_as<Ikarus::Value::SimpleData>() const {
return data_as_SimpleData();
}
template<> inline const Ikarus::Value::CombinedData *PropertyValue::data_as<Ikarus::Value::CombinedData>() const {
return data_as_CombinedData();
}
template<> inline const Ikarus::Value::ListData *PropertyValue::data_as<Ikarus::Value::ListData>() const {
return data_as_ListData();
}
template<> inline const Ikarus::Value::ComplexData *PropertyValue::data_as<Ikarus::Value::ComplexData>() const {
return data_as_ComplexData();
}
struct PropertyValueBuilder {
typedef PropertyValue Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_property_id(int64_t property_id) {
fbb_.AddElement<int64_t>(PropertyValue::VT_PROPERTY_ID, property_id, 0);
}
void add_data_type(Ikarus::Value::Data data_type) {
fbb_.AddElement<uint8_t>(PropertyValue::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
}
void add_data(::flatbuffers::Offset<void> data) {
fbb_.AddOffset(PropertyValue::VT_DATA, data);
}
explicit PropertyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<PropertyValue> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<PropertyValue>(end);
return o;
}
};
inline ::flatbuffers::Offset<PropertyValue> CreatePropertyValue(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t property_id = 0,
Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
::flatbuffers::Offset<void> data = 0) {
PropertyValueBuilder builder_(_fbb);
builder_.add_property_id(property_id);
builder_.add_data(data);
builder_.add_data_type(data_type);
return builder_.Finish();
}
struct PropertyValue::Traits {
using type = PropertyValue;
static auto constexpr Create = CreatePropertyValue;
};
struct Entity FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef EntityBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_NAME = 6,
VT_DESCRIPTION = 8,
VT_TAGS = 10,
VT_VALUES = 12,
VT_PROPERTY_VALUES = 14
};
int64_t id() const {
return GetField<int64_t>(VT_ID, 0);
}
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
const ::flatbuffers::String *description() const {
return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::NamedValue>> *values() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::NamedValue>> *>(VT_VALUES);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::PropertyValue>> *property_values() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::PropertyValue>> *>(VT_PROPERTY_VALUES);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_ID, 8) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_DESCRIPTION) &&
verifier.VerifyString(description()) &&
VerifyOffset(verifier, VT_TAGS) &&
verifier.VerifyVector(tags()) &&
verifier.VerifyVectorOfStrings(tags()) &&
VerifyOffset(verifier, VT_VALUES) &&
verifier.VerifyVector(values()) &&
verifier.VerifyVectorOfTables(values()) &&
VerifyOffset(verifier, VT_PROPERTY_VALUES) &&
verifier.VerifyVector(property_values()) &&
verifier.VerifyVectorOfTables(property_values()) &&
verifier.EndTable();
}
};
struct EntityBuilder {
typedef Entity Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(int64_t id) {
fbb_.AddElement<int64_t>(Entity::VT_ID, id, 0);
}
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Entity::VT_NAME, name);
}
void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
fbb_.AddOffset(Entity::VT_DESCRIPTION, description);
}
void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
fbb_.AddOffset(Entity::VT_TAGS, tags);
}
void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::NamedValue>>> values) {
fbb_.AddOffset(Entity::VT_VALUES, values);
}
void add_property_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::PropertyValue>>> property_values) {
fbb_.AddOffset(Entity::VT_PROPERTY_VALUES, property_values);
}
explicit EntityBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Entity> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Entity>(end);
return o;
}
};
inline ::flatbuffers::Offset<Entity> CreateEntity(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
::flatbuffers::Offset<::flatbuffers::String> name = 0,
::flatbuffers::Offset<::flatbuffers::String> description = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::NamedValue>>> values = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::PropertyValue>>> property_values = 0) {
EntityBuilder builder_(_fbb);
builder_.add_id(id);
builder_.add_property_values(property_values);
builder_.add_values(values);
builder_.add_tags(tags);
builder_.add_description(description);
builder_.add_name(name);
return builder_.Finish();
}
struct Entity::Traits {
using type = Entity;
static auto constexpr Create = CreateEntity;
};
inline ::flatbuffers::Offset<Entity> CreateEntityDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
const char *name = nullptr,
const char *description = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr,
std::vector<::flatbuffers::Offset<Ikarus::NamedValue>> *values = nullptr,
std::vector<::flatbuffers::Offset<Ikarus::PropertyValue>> *property_values = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto description__ = description ? _fbb.CreateString(description) : 0;
auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
auto values__ = values ? _fbb.CreateVectorOfSortedTables<Ikarus::NamedValue>(values) : 0;
auto property_values__ = property_values ? _fbb.CreateVectorOfSortedTables<Ikarus::PropertyValue>(property_values) : 0;
return Ikarus::CreateEntity(
_fbb,
id,
name__,
description__,
tags__,
values__,
property_values__);
}
inline const Ikarus::Entity *GetEntity(const void *buf) {
return ::flatbuffers::GetRoot<Ikarus::Entity>(buf);
}
inline const Ikarus::Entity *GetSizePrefixedEntity(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Ikarus::Entity>(buf);
}
inline bool VerifyEntityBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Ikarus::Entity>(nullptr);
}
inline bool VerifySizePrefixedEntityBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Ikarus::Entity>(nullptr);
}
inline void FinishEntityBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Entity> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedEntityBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Entity> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Ikarus
#endif // FLATBUFFERS_GENERATED_ENTITY_IKARUS_H_

14
include/ikarus/models/property.fbs
View file

@ -1,14 +0,0 @@
include "value.fbs";
namespace Ikarus;
table Property {
id: int64;
name: string;
description: string;
tags: [string];
value_schema: Ikarus.Value.Schema;
default_value: Ikarus.Value.Data;
}
root_type Property;

289
include/ikarus/models/property_generated.h
View file

@ -1,289 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_
#define FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_
#include "flatbuffers/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
FLATBUFFERS_VERSION_MINOR == 3 &&
FLATBUFFERS_VERSION_REVISION == 25,
"Non-compatible flatbuffers version included");
#include "value_generated.h"
namespace Ikarus {
struct Property;
struct PropertyBuilder;
struct Property FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef PropertyBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_NAME = 6,
VT_DESCRIPTION = 8,
VT_TAGS = 10,
VT_VALUE_SCHEMA_TYPE = 12,
VT_VALUE_SCHEMA = 14,
VT_DEFAULT_VALUE_TYPE = 16,
VT_DEFAULT_VALUE = 18
};
int64_t id() const {
return GetField<int64_t>(VT_ID, 0);
}
const ::flatbuffers::String *name() const {
return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
const ::flatbuffers::String *description() const {
return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
}
Ikarus::Value::Schema value_schema_type() const {
return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_VALUE_SCHEMA_TYPE, 0));
}
const void *value_schema() const {
return GetPointer<const void *>(VT_VALUE_SCHEMA);
}
template<typename T> const T *value_schema_as() const;
const Ikarus::Value::ConstantSchema *value_schema_as_ConstantSchema() const {
return value_schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(value_schema()) : nullptr;
}
const Ikarus::Value::SimpleSchema *value_schema_as_SimpleSchema() const {
return value_schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(value_schema()) : nullptr;
}
const Ikarus::Value::CombinedSchema *value_schema_as_CombinedSchema() const {
return value_schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(value_schema()) : nullptr;
}
const Ikarus::Value::ListSchema *value_schema_as_ListSchema() const {
return value_schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(value_schema()) : nullptr;
}
const Ikarus::Value::ComplexSchema *value_schema_as_ComplexSchema() const {
return value_schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(value_schema()) : nullptr;
}
Ikarus::Value::Data default_value_type() const {
return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DEFAULT_VALUE_TYPE, 0));
}
const void *default_value() const {
return GetPointer<const void *>(VT_DEFAULT_VALUE);
}
template<typename T> const T *default_value_as() const;
const Ikarus::Value::ToggleDataPoint *default_value_as_ToggleDataPoint() const {
return default_value_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(default_value()) : nullptr;
}
const Ikarus::Value::NumberDataPoint *default_value_as_NumberDataPoint() const {
return default_value_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(default_value()) : nullptr;
}
const Ikarus::Value::TextDataPoint *default_value_as_TextDataPoint() const {
return default_value_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(default_value()) : nullptr;
}
const Ikarus::Value::SimpleData *default_value_as_SimpleData() const {
return default_value_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(default_value()) : nullptr;
}
const Ikarus::Value::CombinedData *default_value_as_CombinedData() const {
return default_value_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(default_value()) : nullptr;
}
const Ikarus::Value::ListData *default_value_as_ListData() const {
return default_value_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(default_value()) : nullptr;
}
const Ikarus::Value::ComplexData *default_value_as_ComplexData() const {
return default_value_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(default_value()) : nullptr;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_ID, 8) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_DESCRIPTION) &&
verifier.VerifyString(description()) &&
VerifyOffset(verifier, VT_TAGS) &&
verifier.VerifyVector(tags()) &&
verifier.VerifyVectorOfStrings(tags()) &&
VerifyField<uint8_t>(verifier, VT_VALUE_SCHEMA_TYPE, 1) &&
VerifyOffset(verifier, VT_VALUE_SCHEMA) &&
VerifySchema(verifier, value_schema(), value_schema_type()) &&
VerifyField<uint8_t>(verifier, VT_DEFAULT_VALUE_TYPE, 1) &&
VerifyOffset(verifier, VT_DEFAULT_VALUE) &&
VerifyData(verifier, default_value(), default_value_type()) &&
verifier.EndTable();
}
};
template<> inline const Ikarus::Value::ConstantSchema *Property::value_schema_as<Ikarus::Value::ConstantSchema>() const {
return value_schema_as_ConstantSchema();
}
template<> inline const Ikarus::Value::SimpleSchema *Property::value_schema_as<Ikarus::Value::SimpleSchema>() const {
return value_schema_as_SimpleSchema();
}
template<> inline const Ikarus::Value::CombinedSchema *Property::value_schema_as<Ikarus::Value::CombinedSchema>() const {
return value_schema_as_CombinedSchema();
}
template<> inline const Ikarus::Value::ListSchema *Property::value_schema_as<Ikarus::Value::ListSchema>() const {
return value_schema_as_ListSchema();
}
template<> inline const Ikarus::Value::ComplexSchema *Property::value_schema_as<Ikarus::Value::ComplexSchema>() const {
return value_schema_as_ComplexSchema();
}
template<> inline const Ikarus::Value::ToggleDataPoint *Property::default_value_as<Ikarus::Value::ToggleDataPoint>() const {
return default_value_as_ToggleDataPoint();
}
template<> inline const Ikarus::Value::NumberDataPoint *Property::default_value_as<Ikarus::Value::NumberDataPoint>() const {
return default_value_as_NumberDataPoint();
}
template<> inline const Ikarus::Value::TextDataPoint *Property::default_value_as<Ikarus::Value::TextDataPoint>() const {
return default_value_as_TextDataPoint();
}
template<> inline const Ikarus::Value::SimpleData *Property::default_value_as<Ikarus::Value::SimpleData>() const {
return default_value_as_SimpleData();
}
template<> inline const Ikarus::Value::CombinedData *Property::default_value_as<Ikarus::Value::CombinedData>() const {
return default_value_as_CombinedData();
}
template<> inline const Ikarus::Value::ListData *Property::default_value_as<Ikarus::Value::ListData>() const {
return default_value_as_ListData();
}
template<> inline const Ikarus::Value::ComplexData *Property::default_value_as<Ikarus::Value::ComplexData>() const {
return default_value_as_ComplexData();
}
struct PropertyBuilder {
typedef Property Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(int64_t id) {
fbb_.AddElement<int64_t>(Property::VT_ID, id, 0);
}
void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Property::VT_NAME, name);
}
void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
fbb_.AddOffset(Property::VT_DESCRIPTION, description);
}
void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
fbb_.AddOffset(Property::VT_TAGS, tags);
}
void add_value_schema_type(Ikarus::Value::Schema value_schema_type) {
fbb_.AddElement<uint8_t>(Property::VT_VALUE_SCHEMA_TYPE, static_cast<uint8_t>(value_schema_type), 0);
}
void add_value_schema(::flatbuffers::Offset<void> value_schema) {
fbb_.AddOffset(Property::VT_VALUE_SCHEMA, value_schema);
}
void add_default_value_type(Ikarus::Value::Data default_value_type) {
fbb_.AddElement<uint8_t>(Property::VT_DEFAULT_VALUE_TYPE, static_cast<uint8_t>(default_value_type), 0);
}
void add_default_value(::flatbuffers::Offset<void> default_value) {
fbb_.AddOffset(Property::VT_DEFAULT_VALUE, default_value);
}
explicit PropertyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<Property> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<Property>(end);
return o;
}
};
inline ::flatbuffers::Offset<Property> CreateProperty(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
::flatbuffers::Offset<::flatbuffers::String> name = 0,
::flatbuffers::Offset<::flatbuffers::String> description = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0,
Ikarus::Value::Schema value_schema_type = Ikarus::Value::Schema::NONE,
::flatbuffers::Offset<void> value_schema = 0,
Ikarus::Value::Data default_value_type = Ikarus::Value::Data::NONE,
::flatbuffers::Offset<void> default_value = 0) {
PropertyBuilder builder_(_fbb);
builder_.add_id(id);
builder_.add_default_value(default_value);
builder_.add_value_schema(value_schema);
builder_.add_tags(tags);
builder_.add_description(description);
builder_.add_name(name);
builder_.add_default_value_type(default_value_type);
builder_.add_value_schema_type(value_schema_type);
return builder_.Finish();
}
struct Property::Traits {
using type = Property;
static auto constexpr Create = CreateProperty;
};
inline ::flatbuffers::Offset<Property> CreatePropertyDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
int64_t id = 0,
const char *name = nullptr,
const char *description = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr,
Ikarus::Value::Schema value_schema_type = Ikarus::Value::Schema::NONE,
::flatbuffers::Offset<void> value_schema = 0,
Ikarus::Value::Data default_value_type = Ikarus::Value::Data::NONE,
::flatbuffers::Offset<void> default_value = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto description__ = description ? _fbb.CreateString(description) : 0;
auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
return Ikarus::CreateProperty(
_fbb,
id,
name__,
description__,
tags__,
value_schema_type,
value_schema,
default_value_type,
default_value);
}
inline const Ikarus::Property *GetProperty(const void *buf) {
return ::flatbuffers::GetRoot<Ikarus::Property>(buf);
}
inline const Ikarus::Property *GetSizePrefixedProperty(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Ikarus::Property>(buf);
}
inline bool VerifyPropertyBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Ikarus::Property>(nullptr);
}
inline bool VerifySizePrefixedPropertyBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Ikarus::Property>(nullptr);
}
inline void FinishPropertyBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Property> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedPropertyBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Ikarus::Property> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Ikarus
#endif // FLATBUFFERS_GENERATED_PROPERTY_IKARUS_H_

85
include/ikarus/models/value.fbs
View file

@ -1,85 +0,0 @@
namespace Ikarus.Value;
table ToggleDataPoint {
data: [bool];
}
table NumberDataPoint {
data: [double];
}
table TextDataPoint {
data: [string];
}
union Data {
ToggleDataPoint,
NumberDataPoint,
TextDataPoint,
SimpleData,
CombinedData,
ListData,
ComplexData
}
union Schema {
ConstantSchema,
SimpleSchema,
CombinedSchema,
ListSchema,
ComplexSchema
}
table ConstantSchema {
sub_schema: Schema;
data: Data;
}
table SimpleSchema {
sub_schema: Schema;
}
table SimpleData {
data: Data;
}
table CombinedSchema {
schemas: [Schema];
}
table CombinedData {
data: [Data];
}
table ListSchema {
schema: Schema;
}
table ListData {
data: [Data];
}
table NamedSchema {
name: string;
schema: Schema;
}
table ComplexSchema {
schemas: [NamedSchema];
}
table NamedData {
name: string;
data: Data;
}
table ComplexData {
data: [NamedData];
}
table Value {
schema: Schema;
data: Data;
}
root_type Value;

1719
include/ikarus/models/value_generated.h
View file

File diff suppressed because it is too large Load diff

189
include/ikarus/objects/blueprint.h
View file

@ -1,7 +1,7 @@
#pragma once
/// \file blueprint.h
/// \author Folling <folling@ikarus.world>
/// \author Folling <mail@folling.io>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
@ -13,57 +13,113 @@
IKARUS_BEGIN_HEADER
/// \brief Blueprints are templates for managing common properties of entities.
/// \details A blueprint is a collection of properties which can be linked to entities.
/// Each entity the blueprint is linked to will have values for the blueprints
/// properties. Changes in blueprints will be reflected in all linked entities.
/// \brief Templates for sharing common properties between entities.
/// \details A blueprint allows sharing properties between entities.
/// Each entity the blueprint is linked to will have a corresponding value for
/// each of the blueprint's properties. Changes in blueprints will be reflected
/// in all linked entities.
struct IkarusBlueprint;
/// \brief Creates a blueprint.
/// \param project The project the blueprint is part of.
/// \brief Flags for creating a blueprint.
enum IkarusBlueprintCreateFlags {
/// \brief No flags.
IkarusBlueprintCreateFlags_None = 0,
};
/// \brief Creates a new blueprint.
/// \param project The project to create the blueprint in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the blueprint.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \pre \li Must not be empty.
/// \param flags Flags for creating the blueprint.
/// \return The created blueprint or null if an error occurs.
/// \param error_out \see errors.h
/// \remark Ownership remains with libikarus.
IKA_API IkarusBlueprint * ikarus_blueprint_create(
struct IkarusProject * project,
char const * name,
IkarusErrorData * error_out
IkarusBlueprintCreateFlags flags,
struct IkarusErrorData * error_out
);
/// \brief Deletes a blueprint.
/// \brief Flags for creating a blueprint from an entity.
enum IkarusBlueprintCreateFromEntityFlags {
/// \brief No flags.
IkarusBlueprintCreateFromEntityFlags_None = 0,
/// \brief The default values of the properties will be set to the values of the source entity.
IkarusBlueprintCreateFromEntityFlags_AdoptDefaultValues = 1 << 0,
/// \brief The entity will be linked to the blueprint, and all values will be turned into properties.
IkarusBlueprintCreateFromEntityFlags_LinkEntity = 1 << 1,
};
/// \brief Creates a new blueprint from an entity.
/// \details Each value of the entity will be copied into the blueprint as a property.
/// \param entity The entity to create the blueprint from.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the blueprint.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for creating the blueprint.
/// \param error_out \see errors.h
/// \return The created blueprint or null if an error occurs.
IKA_API IkarusBlueprint * ikarus_blueprint_create_from_entity(
struct IkarusEntity * entity,
char const * name,
IkarusBlueprintCreateFromEntityFlags flags,
struct IkarusErrorData * error_out
);
/// \brief Flags for copying a blueprint.
enum IkarusBlueprintCopyFlags {
/// \brief No flags.
IkarusBlueprintCopyFlags_None = 0,
};
/// \brief Copies a blueprint.
/// \param blueprint The blueprint to copy.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param flags Flags for copying the blueprint.
/// \param error_out \see errors.h
/// \return The copied blueprint or null if an error occurs.
IKA_API struct IkarusBlueprint * ikarus_blueprint_copy(
struct IkarusBlueprint * blueprint,
IkarusBlueprintCopyFlags flags,
struct IkarusErrorData * error_out
);
/// \brief Flags for deleting a blueprint.
enum IkarusBlueprintDeleteFlags {
/// \brief No flags.
IkarusBlueprintDeleteFlags_None = 0,
};
/// \brief Deletes a blueprint, all associated properties, and their values.
/// \param blueprint The blueprint to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param flags Flags for deleting the blueprint.
/// \remark Must not be used after deletion.
/// \param error_out \see errors.h
/// \remark The blueprint must not be accessed after deletion.
IKA_API void ikarus_blueprint_delete(
IkarusBlueprint * blueprint,
struct IkarusBlueprint * blueprint,
IkarusBlueprintDeleteFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the ID of a blueprint.
/// \param blueprint The blueprint to get the ID of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The ID of the blueprint or 0 if an error occurs.
IKA_API int64_t ikarus_blueprint_get_id(
IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
);
/// \brief Gets the project a blueprint is part of.
/// \brief Gets the project a blueprint belongs to.
/// \param blueprint The blueprint to get the project of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The project or null if an error occurs.
IKA_API IkarusProject * ikarus_blueprint_get_project(
IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
/// \return The project the blueprint belongs to.
/// \remark Ownership remains with libikarus.
IKA_API struct IkarusProject * ikarus_blueprint_get_project(
struct IkarusBlueprint * blueprint,
struct IkarusErrorData * error_out
);
/// \brief Gets the name of a blueprint.
@ -71,79 +127,84 @@ IKA_API IkarusProject * ikarus_blueprint_get_project(
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The name or null if an error occurs.
/// \return The name of the blueprint.
/// \remark Ownership remains with libikarus.
IKA_API char const * ikarus_blueprint_get_name(
IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
struct IkarusBlueprint * blueprint,
struct IkarusErrorData * error_out
);
/// \brief Flags for setting the name of a blueprint.
enum IkarusBlueprintSetNameFlags {
/// \brief No flags.
IkarusBlueprintSetNameFlags_None = 0,
};
/// \brief Sets the name of a blueprint.
/// \param blueprint The blueprint to set the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The new name of the blueprint.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for setting the name of the blueprint.
/// \param error_out \see errors.h
IKA_API void ikarus_blueprint_set_name(
IkarusBlueprint * blueprint,
struct IkarusBlueprint * blueprint,
char const * name,
IkarusErrorData * error_out
IkarusBlueprintSetNameFlags flags,
struct IkarusErrorData * error_out
);
/// \brief Gets the properties of a blueprint.
/// \param blueprint The blueprint to get the properties of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param properties_out The buffer to write the properties to.
/// \pre \li Must not be null.
/// \param properties_out_size The size of the buffer.
/// \param size_out An out parameter for the number of items in the returned array or undefined if an error occurs.
/// \param error_out \see errors.h
/// \see ikarus_blueprint_get_property_count
IKA_API void ikarus_blueprint_get_properties(
IkarusBlueprint const * blueprint,
struct IkarusProperty ** properties_out,
size_t properties_out_size,
IkarusErrorData * error_out
/// \return The properties of the blueprint or null if an error occurs.
IKA_API struct IkarusProperty ** ikarus_blueprint_get_properties(
struct IkarusBlueprint * blueprint,
size_t * size_out,
struct IkarusErrorData * error_out
);
/// \brief Gets the number of properties of a blueprint.
/// \param blueprint The blueprint to get the number of properties of.
/// \param blueprint The blueprint to get the properties count 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_blueprint_get_property_count(
IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
/// \return The number of properties of the blueprint or 0 if an error occurs.
IKA_API size_t ikarus_blueprint_get_properties_count(
struct IkarusBlueprint * blueprint,
struct IkarusErrorData * error_out
);
/// \brief Gets the entities linked to a blueprint.
/// \param blueprint The blueprint to get the linked entities of.
/// \brief Gets all entities linked to a blueprint.
/// \param blueprint The blueprint to get the entities of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param entities_out The buffer to write the entities to.
/// \pre \li Must not be null.
/// \param entities_out_size The size of the buffer.
/// \param size_out An out parameter for the number of items in the returned array or undefined if an error occurs.
/// \remark Ignore if null.
/// \param error_out \see errors.h
/// \see ikarus_blueprint_get_linked_entity_count
IKA_API void ikarus_blueprint_get_linked_entities(
IkarusBlueprint const * blueprint,
struct IkarusEntity ** entities_out,
size_t entities_out_size,
IkarusErrorData * error_out
/// \return The entities linked to the blueprint or null if an error occurs.
IKA_API struct IkarusEntity ** ikarus_blueprint_get_entities(
struct IkarusBlueprint * blueprint,
size_t * size_out,
struct IkarusErrorData * error_out
);
/// \brief Gets the number of entities linked to a blueprint.
/// \param blueprint The blueprint to get the number of linked entities of.
/// \param blueprint The blueprint to get the entities count of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The number of linked entities or undefined if an error occurs.
IKA_API size_t ikarus_blueprint_get_linked_entity_count(
IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
/// \return The number of entities linked to the blueprint or 0 if an error occurs.
IKA_API size_t ikarus_blueprint_get_entities_count(
struct IkarusBlueprint * blueprint,
struct IkarusErrorData * error_out
);
IKARUS_END_HEADER
// @}
/// @}

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

@ -5,7 +5,7 @@
#include <ikarus/stdtypes.h>
/// \file entity.h
/// \author Folling <folling@ikarus.world>
/// \author Folling <mail@folling.io>
/// \defgroup entities Entities
/// \brief Entities are the core building blocks of Ikarus.
@ -13,15 +13,13 @@
IKARUS_BEGIN_HEADER
/// \brief Entities are the core building blocks of Ikarus.
/// \details Entities store two data: A name and a set of values.
/// The name identifies the entity but does not have to be unique. The values
/// are the actual information of the entity.
/// \details Entities store a number of values associated with a name or property.
///
/// For documentation on the types and layout of values \see Values.h.
/// For documentation on the types and layout of values \see values.h.
///
/// Entities can be linked to blueprints.
/// The entity has a (possibly uninitialized) value for each property of all
/// blueprints it is linked to. \see Property.h \see Blueprint.h.
/// blueprints it is linked to. \see property.h \see blueprint.h.
///
/// We distinguish between `EntityValues` and `EntityPropertyValues`.
/// `EntityValues` are a direct part of the entity.
@ -29,59 +27,89 @@ IKARUS_BEGIN_HEADER
/// via a blueprint.
struct IkarusEntity;
/// \brief Creates an entity.
/// \param project The project the entity is part of.
/// \brief Flags for creating an entity.
enum IkarusEntityCreateFlags {
/// \brief No flags.
IkarusEntityCreateFlags_None = 0,
};
/// \brief Creates a new entity.
/// \param project The project to create the entity in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the entity.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for creating the entity.
/// \param error_out \see errors.h
/// \return The created entity or null if an error occurs.
IKA_API IkarusEntity * ikarus_entity_create(
struct IkarusProject * project,
char const * name,
IkarusEntityCreateFlags flags,
IkarusErrorData * error_out
);
/// \brief Deletes an entity.
/// \brief Flags for deleting an entity.
enum IkarusEntityDeleteFlags {
/// \brief No flags.
IkarusEntityDeleteFlags_None = 0,
};
/// \brief Deletes an entity and its values.
/// \param entity The entity to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param flags Flags for deleting the entity.
/// \param error_out \see errors.h
/// \remark The entity must not be accessed after deletion.
IKA_API void
ikarus_entity_delete(IkarusEntity * entity, IkarusErrorData * error_out);
IKA_API void ikarus_entity_delete(
IkarusEntity * entity,
IkarusEntityDeleteFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the id of an entity.
/// \param entity The entity to get the id of.
/// \brief Flags for copying an entity.
enum IkarusEntityCopyFlags {
/// \brief No flags.
IkarusEntityCopyFlags_None = 0,
};
/// \brief Copies an entity.
/// \param entity The entity to copy.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param flags Flags for copying the entity.
/// \param error_out \see errors.h
/// \return The id of the entity or 0 if an error occurs.
IKA_API int64_t
ikarus_entity_get_id(IkarusEntity const * entity, IkarusErrorData * error_out);
/// \return The copied entity or null if an error occurs.
IKA_API IkarusEntity * ikarus_entity_copy(
IkarusEntity * entity,
IkarusEntityCopyFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the project an entity is part of.
/// \brief Gets the project an entity belongs to.
/// \param entity The entity to get the project of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The project the entity is part of or null if an error occurs.
IKA_API IkarusProject * ikarus_entity_get_project(
IkarusEntity const * entity,
IkarusErrorData * error_out
);
/// \return The project the entity belongs to.
IKA_API struct IkarusProject *
ikarus_entity_get_project(IkarusEntity * entity, IkarusErrorData * error_out);
/// \brief Gets the name of an entity.
/// \param entity The entity to get the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The name of the entity or null if an error occurs.
IKA_API char const * ikarus_entity_get_name(
IkarusEntity const * entity,
IkarusErrorData * error_out
);
/// \return The name of the entity.
IKA_API char const *
ikarus_entity_get_name(IkarusEntity * entity, IkarusErrorData * error_out);
/// \brief Flags for setting the name of an entity.
enum IkarusEntitySetNameFlags {
/// \brief No flags.
IkarusEntitySetNameFlags_None = 0,
};
/// \brief Sets the name of an entity.
/// \param entity The entity to set the name of.
@ -89,72 +117,26 @@ IKA_API char const * ikarus_entity_get_name(
/// \pre \li Must exist.
/// \param name The new name of the entity.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for setting the name of the entity.
/// \param error_out \see errors.h
IKA_API void ikarus_entity_set_name(
IkarusEntity * entity,
char const * name,
IkarusEntitySetNameFlags flags,
IkarusErrorData * error_out
);
/// \brief Checks if an entity is linked to a blueprint.
/// \param entity The entity to check.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param blueprint The blueprint to check.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return True if the entity is linked to the blueprint, false otherwise.
IKA_API bool ikarus_entity_is_linked_to_blueprint(
IkarusEntity const * entity,
struct IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
);
/// \brief Links an entity to a blueprint.
/// \param entity The entity to link.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param blueprint The blueprint to link the entity to.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \remark No-op if the entity is already linked to the blueprint.
IKA_API void ikarus_entity_link_to_blueprint(
IkarusEntity * entity,
struct IkarusBlueprint * blueprint,
IkarusErrorData * error_out
);
/// \brief Unlinks an entity from a blueprint.
/// All values of the blueprints' properties will be deleted.
/// \param entity The entity to unlink.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param blueprint The blueprint to unlink the entity from.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \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
);
/// \brief Gets all blueprints an entity is linked to.
/// \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 size_out An out parameter for the number of blueprints in the returned array
/// or undefined if an error occurs.
/// \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,
IKA_API struct IkarusBlueprint ** ikarus_entity_get_linked_blueprints(
IkarusEntity * entity,
size_t * size_out,
IkarusErrorData * error_out
);
@ -163,121 +145,154 @@ IKA_API void ikarus_entity_get_linked_blueprints(
/// \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,
/// \return The number of linked blueprints or 0 if an error occurs.
IKA_API size_t ikarus_entity_get_linked_blueprints_count(
IkarusEntity * entity,
IkarusErrorData * error_out
);
/// \brief Checks if an entity has a value with a given name.
/// \param entity The entity to check.
/// \brief Flags for linking an entity to a blueprint.
enum IkarusEntityLinkBlueprintFlags {
/// \brief No flags.
IkarusEntityLinkBlueprintFlags_None = 0,
};
/// \brief Links an entity to a blueprint.
/// \details An uninitialized (default) value is created for each property of the
/// blueprint.
/// \param entity The entity to link the blueprint to.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the value to check.
/// \param blueprint The blueprint to link to.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \pre \li Must be in the same project as the entity.
/// \remark If the entity is already linked to the blueprint, nothing happens.
/// \param flags Flags for linking the entity to the blueprint.
/// \param error_out \see errors.h
/// \return False if the entity does not have a value associated with
/// the name or if an error occurs, true otherwise.
IKA_API bool ikarus_entity_has_value(
IkarusEntity const * entity,
char const * name,
IKA_API void ikarus_entity_link_blueprint(
IkarusEntity * entity,
struct IkarusBlueprint * blueprint,
IkarusEntityLinkBlueprintFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the value of an entity.
/// \brief Flags for unlinking an entity from a blueprint.
enum IkarusEntityUnlinkBlueprintFlags {
/// \brief No flags.
IkarusEntityUnlinkBlueprintFlags_None = 0,
/// \brief Keep the values associated with the blueprint, transforming them into entity values.
IkarusEntityUnlinkBlueprintFlags_KeepValues = 1,
};
/// \brief Unlinks an entity from a blueprint.
/// \details All values associated with the blueprint are deleted.
/// \param entity The entity to unlink the blueprint from.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param blueprint The blueprint to unlink from.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \remark If the entity is not linked to the blueprint, nothing happens.
/// \param flags Flags for unlinking the entity from the blueprint.
/// \param error_out \see errors.h
IKA_API void ikarus_entity_unlink_blueprint(
IkarusEntity * entity,
struct IkarusBlueprint * blueprint,
IkarusEntityUnlinkBlueprintFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the values of an entity.
/// \param entity The entity to get the values of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The values, in json format of or null if an error occurs.
/// The json representation is an array of objects with the following keys:
/// - `name`: The name of the value.
/// - `value`: The value itself. \see value.h
IKA_API char const *
ikarus_entity_get_values(IkarusEntity * entity, IkarusErrorData * error_out);
/// \brief Gets a value of an entity.
/// \param entity The entity to get the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the value to get.
/// \param name The value's name.
/// \pre \li Must not be null.
/// \pre \li Must be an existing value of the entity.
/// \remark Ownership remains with the client.
/// \param error_out \see errors.h
/// \return The value of the entity or null if an error occurs.
IKA_API struct IkarusValue * ikarus_entity_get_value(
IkarusEntity const * entity,
/// \return The value, in json format of or null if an error occurs. \see value.h
IKA_API char const * ikarus_entity_get_value(
IkarusEntity * entity,
char const * name,
IkarusErrorData * error_out
);
/// \brief Sets the value of an entity.
/// If the entity does not have a value associated with the name, it is created.
/// \remark Types are overwritten if the value already exists.
/// \brief Flags for setting a value of an entity.
enum IkarusEntitySetValueFlags {
/// \brief No flags.
IkarusEntitySetValueFlags_None = 0,
};
/// \brief Sets a value of an entity.
/// \details If no value exists for the name, a new one is created.
/// Any previous value is overwritten.
/// \param entity The entity to set the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the value to set.
/// \param name The value's name.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param value The new value of the entity.
/// \param value The value to set.
/// \pre \li Must not be null.
/// \pre \li Must be a valid json representation of a value. \see value.h
/// \param flags Flags for setting the value.
/// \param error_out \see errors.h
IKA_API void ikarus_entity_set_value(
IkarusEntity * entity,
char const * name,
struct IkarusValue const * value,
char const * value,
IkarusEntitySetValueFlags flags,
IkarusErrorData * error_out
);
/// \brief Removes a value from an entity.
/// \pre \li The value must exist.
/// \brief Flags for deleting a value of an entity.
enum IkarusEntityDeleteValueFlags {
/// \brief No flags.
IkarusEntityDeleteValueFlags_None = 0,
};
/// \brief Deletes a value of an entity.
/// \param entity The entity to delete the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the value to delete.
/// \param name The property's name to delete the value of.
/// \pre \li Must not be null.
/// \pre \li Must be the name of a value which exists within the property.
/// \param flags Flags for deleting the value.
/// \param error_out \see errors.h
IKA_API void ikarus_entity_remove_value(
IKA_API void ikarus_entity_delete_value(
IkarusEntity * entity,
char const * name,
IkarusEntityDeleteValueFlags flags,
IkarusErrorData * error_out
);
/// \brief Checks if a property is linked to an entity.
/// \param entity The entity to check.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param property The property to check.
/// \brief Gets the property values of an entity.
/// \param entity The entity to get the property values of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \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
);
/// \brief Gets the properties an entity is linked to.
/// \param entity The entity to get the linked properties of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param properties_out The buffer to write the linked properties to.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \param properties_out_size The size of the buffer.
/// \see ikarus_entity_get_property_count
IKA_API void ikarus_entity_get_properties(
IkarusEntity const * entity,
struct IkarusProperty ** properties_out,
size_t properties_out_size,
IkarusErrorData * error_out
);
/// \brief Gets the number of properties an entity is linked to.
/// \param entity The entity to get the number of linked 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,
/// \return The property values, in msgpack format of or null if an error occurs.
/// The format is a map of property pointers (as integers) to values. \see
/// value.h
IKA_API char const * ikarus_entity_get_property_values(
IkarusEntity * entity,
IkarusErrorData * error_out
);
/// \brief Gets the value of a property of an entity.
/// \details If the entity has never set the value of the property,
/// the property's default value is returned.
/// \param entity The entity to get the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
@ -286,33 +301,43 @@ IKA_API size_t ikarus_entity_get_property_count(
/// \pre \li Must exist.
/// \pre \li Must be linked to the entity.
/// \param error_out \see errors.h
/// \return The value of the property or null if an error occurs.
IKA_API struct IkarusValue * ikarus_entity_get_property_value(
IkarusEntity const * entity,
struct IkarusProperty const * property,
/// \return The value, in json format of or null if an error occurs. \see
/// value.h
IKA_API char const * ikarus_entity_get_property_value(
IkarusEntity * entity,
struct IkarusProperty * property,
IkarusErrorData * error_out
);
/// \brief Flags for setting the value of a property of an entity.
enum IkarusEntitySetPropertyValueFlags {
/// \brief No flags.
IkarusEntitySetPropertyValueFlags_None = 0,
};
/// \brief Sets the value of a property of an entity.
/// \param entity The entity to set the property value of.
/// \details Any previous value is overwritten.
/// \param entity The entity to set the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param property The property to set the value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param value The new value of the property.
/// \pre \li Must be linked to the entity.
/// \param value The value to set.
/// \pre \li Must not be null.
/// \pre \li Must be of the same type as the property.
/// \pre \li Must be valid for the property's settings.
/// \pre \li Must be a valid json representation of a value. \see value.h
/// \pre \li Must be valid for the property's schema. \see schema.h
/// \param flags Flags for setting the property value.
/// \param error_out \see errors.h
/// \remark If the entity does not have the property, this function fails.
IKA_API void ikarus_entity_set_property_value(
IkarusEntity * entity,
struct IkarusProperty const * property,
struct IkarusValue const * value,
struct IkarusProperty * property,
char const * value,
IkarusEntitySetPropertyValueFlags flags,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
// @}
/// @}

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

@ -1,40 +0,0 @@
#pragma once
/// \file number_property.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
/// \addtogroup properties Properties
/// \brief Number properties store a value that can be either true or false. (e.g. "Is the character dead?")
/// @{
IKARUS_BEGIN_HEADER
struct IkarusNumberProperty;
/// \brief Creates a number property.
/// \param project The project to create the property in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the property.
/// \pre \li Must not be null.
/// \param property_source The property source to create the property for.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param default_value The default value for the property.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The created property or null if an error occurs.
IKA_API IkarusNumberProperty * ikarus_number_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
struct IkarusNumberValue * default_value,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
/// @}

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

@ -1,144 +0,0 @@
#pragma once
/// \file property.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
#include <ikarus/values/value_cardinality.h>
#include <ikarus/values/value_type.h>
/// \defgroup properties Properties
/// \brief Properties define the structure and types of data.
/// @{
IKARUS_BEGIN_HEADER
/// \brief Properties define the structure of blueprints.
/// \details Each blueprint can have any number of properties.
/// Every property has a type that identifies the kind of data that can be put in.
/// This is the "base class" of properties. See the derived types (e.g. IkarusToggleProperty) for more information.
///
/// The following types currently exist:
/// - Toggle: A true/false boolean-like value
/// - Number: An arbitrary numeric value
/// - Text: An arbitrary textual value
///
/// Property Examples:
/// - Is Dead (Toggle)
/// - Age (Number)
/// - ISBN (Text)
///
/// Each entity associated with the property has a value for it.
///
/// \remark Values for properties are lazily created to save space.
/// Fetching the value for some property of some entity will return the property's default value if none is specified.
struct IkarusProperty;
/// \brief Deletes a property.
/// \param property The property to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \remark The property must not be accessed after deletion.
IKA_API void ikarus_property_delete(IkarusProperty * property, IkarusErrorData * error_out);
/// \brief Gets the ID of a property.
/// \param property The property to get the ID of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The ID of the property or 0 if an error occurs.
IKA_API int64_t ikarus_property_get_id(IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Gets the project of a property.
/// \param property The property to get the project of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The project of the property or null if an error occurs.
IKA_API struct IkarusProject * ikarus_property_get_project(IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Gets the name of an property.
/// \param entity The property to get the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The name of the property or null if an error occurs.
IKA_API char const * ikarus_property_get_name(IkarusProperty const * entity, IkarusErrorData * error_out);
/// \brief Sets the name of an property.
/// \param entity The property to set the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The new name of the property.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
IKA_API void ikarus_property_set_name(IkarusProperty * entity, char const * name, IkarusErrorData * error_out);
/// \brief Gets the type info of a property.
/// \param property The property to get the type info of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The type info of the property or null if an error occurs.
/// \remark Changing the type of a property is not supported. This is because the property would need to change
IKA_API IkarusValueType ikarus_property_get_type(IkarusProperty const * property, IkarusErrorData * error_out);
// there is no `set_type` as we encode type information in the underlying datatype
/// \briefs Gets a property's cardinality.
/// \param property The property to get the cardinality of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The cardinality of the property or false if an error occurs.
IKA_API IkarusValueCardinality ikarus_property_get_cardinality(IkarusProperty const * property, IkarusErrorData * error_out);
/// \briefs Sets a property's default value.
/// \param property The property to set the cardinality of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \\param cardinality The new cardinality of the property.
/// \param error_out \see errors.h
IKA_API void
ikarus_property_set_cardinality(IkarusProperty * property, IkarusValueCardinality cardinality, IkarusErrorData * error_out);
/// \briefs Gets a property's default value.
/// \param property The property to get the default value of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The default value of the property or null if an error occurs.
IKA_API struct IkarusValue * ikarus_property_get_default_value(IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Gets the source blueprint of a property.
/// \param property The property to get the source of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The source of the property or null if an error occurs.
IKA_API struct IkarusBlueprint * ikarus_property_get_blueprint(IkarusProperty const * property, IkarusErrorData * error_out);
/// \brief Visits a property. Calling the appropriate function for the property's type.
/// \param property The property to visit.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param toggle_property_visitor The function to call if the property is a toggle property. Skipped if null.
/// \param number_property_visitor The function to call if the property is a number property. Skipped if null.
/// \param text_property_visitor The function to call if the property is a text property. Skipped if null.
/// \param data The data to pass to the functions.
/// \param error_out \see errors.h
IKA_API void ikarus_property_visit(
IkarusProperty * property,
void (*toggle_property_visitor)(struct IkarusToggleProperty *, void *),
void (*number_property_visitor)(struct IkarusNumberProperty *, void *),
void (*text_property_visitor)(struct IkarusTextProperty *, void *),
void * data,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
// @}

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

@ -1,40 +0,0 @@
#pragma once
/// \file text_property.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
/// \addtogroup properties Properties
/// \brief Text properties store a value that can be either true or false. (e.g. "Is the character dead?")
/// @{
IKARUS_BEGIN_HEADER
struct IkarusTextProperty;
/// \brief Creates a text property.
/// \param project The project to create the property in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the property.
/// \pre \li Must not be null.
/// \param property_source The property source to create the property for.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param default_value The default value for the property.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The created property or null if an error occurs.
IKA_API IkarusTextProperty * ikarus_text_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
struct IkarusTextValue * default_value,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
/// @}

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

@ -1,37 +0,0 @@
#pragma once
/// \file toggle_property.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
/// \addtogroup properties Properties
/// @{
IKARUS_BEGIN_HEADER
/// \brief Toggle properties store a value that can be either true or false. (e.g. "Is the character dead?")
struct IkarusToggleProperty;
/// \brief Creates a toggle property.
/// \param project The project to create the property in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the property.
/// \pre \li Must not be null.
/// \param property_source The property source to create the property for.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The created property or null if an error occurs.
IKA_API IkarusToggleProperty * ikarus_toggle_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertySource * property_source,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
/// @}

143
include/ikarus/objects/property.h Normal file
View file

@ -0,0 +1,143 @@
#pragma once
/// \file property.h
/// \author Folling <mail@folling.io>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
/// \defgroup properties Properties
/// \brief Properties define the structure and types of data.
/// @{
IKARUS_BEGIN_HEADER
/// \brief Properties define the structure of blueprints.
/// \details Each blueprint can have any number of properties.
/// Every property has a type that identifies the kind of data that can be put
/// in. This is the "base class" of properties. See the derived types (e.g.
/// IkarusToggleProperty) for more information.
///
/// The following types currently exist:
/// - Toggle: A true/false boolean-like value
/// - Number: An arbitrary numeric value
/// - Text: An arbitrary textual value
///
/// Property Examples:
/// - Is Dead (Toggle)
/// - Age (Number)
/// - ISBN (Text)
///
/// Each entity associated with the property has a value for it.
///
/// \remark Values for properties are lazily created to save space.
/// Fetching the value for some property of some entity will return the
/// property's default value if none is specified.
struct IkarusProperty;
/// \brief Flags for creating a property.
enum IkarusPropertyCreateFlags {
/// \brief No flags.
IkarusPropertyCreateFlags_None = 0,
};
/// \brief Create a new property.
/// \param project The project to create the property in.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The name of the property.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param schema The schema of the property.
/// \pre \li Must not be null.
/// \param flags Flags for creating the property.
/// \param error_out \see errors.h
/// \return The created property or NULL if an error occurred.
/// \remark Must only be deleted with #ikarus_property_delete.
IKA_API IkarusProperty * ikarus_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusValueSchema * schema,
IkarusPropertyCreateFlags flags,
IkarusErrorData * error_out
);
/// \brief Flags for deleting a property.
enum IkarusPropertyDeleteFlags {
/// \brief No flags.
IkarusPropertyDeleteFlags_None = 0,
};
/// \brief Delete a property.
/// \param property The property to delete.
/// \param flags Flags for deleting the property.
/// \param error_out \see errors.h
IKA_API void ikarus_property_delete(
IkarusProperty * property,
IkarusPropertyDeleteFlags flags,
IkarusErrorData * error_out
);
/// \brief Get the project a property belongs to.
/// \param property The property to get the project of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The project the property belongs to or null if an error occurred.
/// \remark Ownership remains with libikarus.
IKA_API struct IkarusProject * ikarus_property_get_project(
IkarusProperty * property,
IkarusErrorData * error_out
);
/// \brief Get the name of a property.
/// \param property The property to get the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The name of the property or null if an error occurred.
/// \remark Ownership remains with libikarus.
IKA_API char const * ikarus_property_get_name(
IkarusProperty * property,
IkarusErrorData * error_out
);
/// \brief Get the schema of a property.
/// \param property The property to get the schema of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The schema of the property or null if an error occurred.
/// \remark Ownership remains with libikarus.
IKA_API struct IkarusValueSchema * ikarus_property_get_schema(
IkarusProperty * property,
IkarusErrorData * error_out
);
/// \brief Flags for setting the name of a property.
enum IkarusPropertySetNameFlags {
/// \brief No flags.
IkarusPropertySetNameFlags_None = 0,
};
/// \brief Set the name of a property.
/// \param property The property to set the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param name The new name of the property.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for setting the name of the property.
/// \param error_out \see errors.h
/// \remark Ownership remains with the caller.
IKA_API void ikarus_property_set_name(
IkarusProperty * property,
char const * name,
IkarusPropertySetNameFlags flags,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
/// @}

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

@ -1,7 +1,9 @@
#pragma once
/// \file project.h
/// \author Folling <folling@ikarus.world>
/// \author Folling <mail@folling.io>
#include <cstdint>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
@ -15,10 +17,19 @@
IKARUS_BEGIN_HEADER
/// \brief An Ikarus project.
/// \details A project may only be open once at a time. Opening a project from two different locations Gets undefined
/// \details A project may only be open once at a time.
/// Opening a project from two different locations results in undefined
/// behavior.
struct IkarusProject;
/// \brief Flags for creating a project.
enum IkarusProjectCreateFlags {
/// \brief No flags.
IkarusProjectCreateFlags_None = 0,
/// \brief Allow overwriting existing files.
IkarusProjectCreateFlags_AllowOverwrite = 1 << 0,
};
/// \brief Creates a persisted project on the filesystem.
/// \param path The path to the project.
/// \pre \li Must not be null.
@ -26,124 +37,166 @@ struct IkarusProject;
/// \param name The name of the project. Must neither be null nor empty.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for creating the project.
/// \param error_out \see errors.h
/// \return The created project or null if an error occurs.
/// \remark Must be freed using #ikarus_free. Freeing does not delete the project from the filesystem. For that, use
/// ikarus_project_delete
IKA_API IkarusProject * ikarus_project_create(
/// \remark Must be closed with #ikarus_project_close.
IKA_API struct IkarusProject * ikarus_project_create(
char const * path,
char const * name,
IkarusProjectCreateFlags flags,
IkarusErrorData * error_out
);
/// \brief Creates a project in memory.
/// \brief Flags for creating a project in memory.
enum IkarusProjectCreateInMemoryFlags {
/// \brief No flags.
IkarusProjectCreateInMemoryFlags_None = 0,
};
/// \brief Creates a project in memory. The project is not persisted.
/// \param name The name of the project. Must neither be null nor empty.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for creating the project.
/// \param error_out \see errors.h
/// \return The created project or null if an error occurs.
/// \remark Must be freed using #ikarus_free. Freeing does not delete the project from the filesystem. For that, use
/// ikarus_project_delete
IKA_API IkarusProject *
ikarus_project_create_in_memory(char const * name, IkarusErrorData * error_out);
/// \remark Must be closed with #ikarus_project_close.
IKA_API struct IkarusProject * ikarus_project_create_in_memory(
char const * name,
IkarusProjectCreateInMemoryFlags flags,
IkarusErrorData * error_out
);
/// \brief Flags for opening a project.
enum IkarusProjectOpenFlags {
/// \brief No flags.
IkarusProjectOpenFlags_None = 0,
};
/// \brief Opens an existing project.
/// \param path The path to the project.
/// \pre \li Must not be null.
/// \pre \li Must point to an existing project on the system.
/// \param flags Flags for opening the project.
/// \param error_out \see errors.h
/// \return The opened project or null if an error occurs.
/// \remark Must be freed using ikarus_free. Freeing does not delete the project from the filesystem. For that, use
/// ikarus_project_delete
IKA_API IkarusProject *
ikarus_project_open(char const * path, IkarusErrorData * error_out);
/// \brief Gets the name of a project.
/// \param project The project to get the name of.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The name of the project.
/// \remark Ownership remains with libikarus, must not be freed.
IKA_API char const * ikarus_project_get_name(
IkarusProject const * project,
/// \remark Must be closed with #ikarus_project_close.
IKA_API struct IkarusProject * ikarus_project_open(
char const * path,
IkarusProjectOpenFlags flags,
IkarusErrorData * error_out
);
/// \brief Sets the name of a project.
/// \param project The project to set the name of.
/// \brief Flags for closing a project in memory.
enum IkarusProjectCloseFlags {
/// \brief No flags.
IkarusProjectCloseFlags_None = 0,
};
/// \brief Closes a project. This function must be called to free resources.
/// \param project The project to close.
/// \pre \li Must not be null.
/// \pre \li Must be open.
/// \param flags Flags for closing the project.
/// \param error_out \see errors.h
/// \remark The project must not be used after closing.
/// \remark Does not delete the project from the filesystem.
/// \remark Mutually exclusive with #ikarus_project_delete.
IKA_API void ikarus_project_close(
struct IkarusProject * project,
IkarusProjectCloseFlags flags,
IkarusErrorData * error_out
);
/// \brief Flags for deleting a project.
enum IkarusProjectDeleteFlags {
/// \brief No flags.
IkarusProjectDeleteFlags_None = 0,
};
/// \brief Deletes a project from the filesystem.
/// \param project The project to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param new_name The new name of the project.
/// \pre \li Must not be null.
/// \pre \li Must not be empty.
/// \param flags Flags for deleting the project.
/// \param error_out \see errors.h
IKA_API void ikarus_project_set_name(
IkarusProject * project,
char const * new_name,
/// \remark The project must not be used after deletion.
/// \remark Mutually exclusive with #ikarus_project_close.
IKA_API void ikarus_project_delete(
struct IkarusProject * project,
IkarusProjectDeleteFlags flags,
IkarusErrorData * error_out
);
/// \brief Gets the name of a project.
/// \param project The project to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \returns The name of the project or null if an error occurs.
IKA_API char const * ikarus_project_get_name(
struct IkarusProject const * project,
IkarusErrorData * error_out
);
/// \brief Gets the path of a project.
/// \param project The project to get the path of.
/// \param project The project to delete.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The path of the project.
/// \remark Ownership remains with libikarus, must not be freed.
/// \returns The path of the project or null if an error occurs.
IKA_API char const * ikarus_project_get_path(
struct IkarusProject const * project,
IkarusErrorData * error_out
);
/// \brief Gets all entities in a project.
/// \param project The project from which to get the entities.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param size_out An out parameter for the number of entities in the returned array
/// or undefined if an error occurs.
/// \param error_out \see errors.h
/// \returns An array of entities or null if an error occurs.
IKA_API struct IkarusEntity ** ikarus_project_get_entities(
struct IkarusProject const * project,
size_t * size_out,
IkarusErrorData * error_out
);
/// \brief Gets how many entities in a project there are.
/// \param project The project from which to get the count.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \return The count or 0 if an error occurs.
IKA_API size_t ikarus_project_get_entities_count(
IkarusProject const * project,
IkarusErrorData * error_out
);
/// \brief Gets the entities of a project.
/// \param project The project to get the entities of.
/// \brief Gets all blueprints from a project.
/// \param project The project from which to get the blueprints.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param entities_out The buffer to write the entities to.
/// \pre \li Must not be null.
/// \param entities_out_size The size of the buffer.
/// \param size_out An out parameter for the number of blueprints in the returned array
/// or undefined if an error occurs.
/// \param error_out \see errors.h
IKA_API void ikarus_project_get_entities(
IkarusProject * project,
struct IkarusEntity ** entities_out,
size_t entities_out_size,
/// \return An array of blueprints or null if an error occurs.
IKA_API struct IkarusBlueprint ** ikarus_project_get_blueprints(
struct IkarusProject const * project,
size_t * size_out,
IkarusErrorData * error_out
);
/// \brief Gets the number of entities of a project.
/// \param project The project to get the number of entities of.
/// \brief Gets how many blueprints in a project there are.
/// \param project The project from which to get the count.
/// \pre \li Must not be null.
/// \pre \li Must exist.
/// \param error_out \see errors.h
/// \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
);
/// \brief Gets the blueprints of a project.
/// \param project The project 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
IKA_API void ikarus_project_get_blueprints(
IkarusProject * project,
struct IkarusBlueprint ** blueprints_out,
size_t blueprints_out_size,
IkarusErrorData * error_out
);
/// \brief Gets the number of blueprints of a project.
/// \param project The project 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_project_get_blueprint_count(
/// \return The count or 0 if an error occurs.
IKA_API size_t ikarus_project_get_blueprints_count(
IkarusProject const * project,
IkarusErrorData * error_out
);

9
include/ikarus/stdtypes.h
View file

@ -1,10 +1,11 @@
#pragma once
#ifdef __cplusplus
#include <cstddef>
#include <cstdint>
#include <cstddef>
#include <cstdint>
using std::size_t;
#else
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#endif

48
include/ikarus/values/data.h Normal file
View file

@ -0,0 +1,48 @@
#pragma once
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
/// \file data.h
/// \author Folling <mail@folling.io>
/// \addtogroup values Values
IKARUS_BEGIN_HEADER
/// \brief Data stores the actual information of a value.
/// \details Data is schemaless and can store any kind of data. Only when the
/// data is combined with a schema does it become a value. \see value.h.
/// Given the complexity of data, they are transferred as json.
/// The json representation of a data is a map with the following keys:
/// - `type` The type of the data. \see IkarusValueDataType. Must be one of the
/// following:
/// - `Primitive` A primitive value. Has two additional key:
/// - `primitive` The type of the primitive. Must be one of the following:
/// - `data` The stored data. Must be either a bool, double, or string.
/// - `Constant` A constant value. Has no additional keys, as the constant
/// value is shared across all values.
/// - `List` A list of values. Has the following additional keys:
/// - `data` An array of stored data.
/// - `Map` A map of key-value pairs. Has the following additional keys:
/// - `data` An array of key-value pairs.
/// - `Tuple` A tuple of values. Has the following additional keys:
/// - `data` An array of stored data.
/// Note that each sub-data is also a data, allowing for arbitrarily nested data
/// structures.
struct IkarusValueData;
/// \brief The type of data.
enum IkarusValueDataType {
/// \brief A primitive value. \see IkarusValuePrimitiveType.
IkarusValueDataType_Primitive = 1,
/// \brief A list of values.
IkarusValueDataType_List = 2,
/// \brief A map of key-value pairs.
IkarusValueDataType_Map = 3,
/// \brief A tuple of values.
IkarusValueDataType_Tuple = 4,
};
IKARUS_END_HEADER

109
include/ikarus/values/number_value.h
View file

@ -1,109 +0,0 @@
#pragma once
/// \file number_value.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/values/value_cardinality.h>
/// \addtogroup values Values
/// @{
IKARUS_BEGIN_HEADER
/// \brief A numeric value. For example "Age" or "Height".
struct IkarusNumberValue;
/// \brief Creates an empty number value.
/// \details If the cardinality is "Single", the value will be initialized with 0.0.
/// \param cardinality The cardinality of the value.
/// \param error_out \see errors.h
/// \return The value or null if an error occurs.
IKA_API IkarusNumberValue * ikarus_number_value_create(IkarusValueCardinality cardinality, IkarusErrorData * error_out);
/// \brief Fetches the underlying data of a number value at a specific index.
/// \param value The number value.
/// \pre \li Must not be null.
/// \param idx The index of the data to fetch.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
/// \return The underlying data or NaN if an error occurs.
IKA_API double ikarus_number_value_get(IkarusNumberValue const * value, size_t idx, IkarusErrorData * error_out);
/// \brief Fetches the size of the underlying data of a number value.
/// \param value The number value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The size of the underlying data or 0 if an error occurs.
IKA_API size_t ikarus_number_value_get_size(IkarusNumberValue const * value, IkarusErrorData * error_out);
/// \brief Sets the data of a number value at a specific index.
/// \param value The number value.
/// \pre \li Must not be null.
/// \param idx The index of the data to set.
/// \pre \li Must be less than the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_number_value_set(IkarusNumberValue * value, size_t idx, double new_data, IkarusErrorData * error_out);
/// \brief Inserts a data into a number value.
/// \param value The number value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to insert.
/// \pre \li Must be less than or equal to the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_number_value_insert(IkarusNumberValue * value, size_t idx, double new_data, IkarusErrorData * error_out);
/// \brief Removes a data from a number value.
/// \param value The number value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to remove.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
IKA_API void ikarus_number_value_remove(IkarusNumberValue * value, size_t idx, IkarusErrorData * error_out);
/// \brief Clears a number value.
/// \param value The number value.
/// \pre \li Cardinality must be "Multiple".
/// \param error_out \see errors.h
IKA_API void ikarus_number_value_clear(IkarusNumberValue * value, IkarusErrorData * error_out);
/// \brief Converts a number value to a string.
/// \param value The number value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted string.
/// \remark Must be freed with #ikarus_free.
IKA_API char const * ikarus_number_value_to_string(IkarusNumberValue const * value, IkarusErrorData * error_out);
/// \brief Checks if two values are equal.
/// \param lhs The left hand side value.
/// \pre \li Must not be null.
/// \param rhs The right hand side value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return True if the values' data are equal, false otherwise.
IKA_API bool ikarus_number_value_is_equal(IkarusNumberValue const * lhs, IkarusNumberValue const * rhs, IkarusErrorData * error_out);
/// \brief Creates a copy of a number value.
/// \param value The value to copy.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The copied value.
IKA_API IkarusNumberValue * ikarus_number_value_copy(IkarusNumberValue const * value, IkarusErrorData * error_out);
/// \brief Converts a number value to an entity value.
/// \param value The number value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted entity value.
/// \remark This is the same pointer, so freeing it implies freeing the original value.
IKA_API struct IkarusValueData * ikarus_number_value_to_value(IkarusNumberValue * value, IkarusErrorData * error_out);
IKARUS_END_HEADER
/// @}

58
include/ikarus/values/schema.h Normal file
View file

@ -0,0 +1,58 @@
#pragma once
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
/// \file schema.h
/// \author Folling <mail@folling.io>
/// \addtogroup values Values
IKARUS_BEGIN_HEADER
/// \brief Schemas define the type of value.
/// \details Schemas are used to define the type of value. They are akin to
/// classes in programming languages.
/// Schemas are used to validate values and structure data.
///
/// Given the complexity of schemas, they are transferred as json.
/// The json representation of a schema is a map with the following keys:
/// - `type` The type of the schema. Must be one of the following:
/// - `Primitive` A primitive value. Has the following additional keys:
/// - `primitive` The type of the primitive value. \see IkarusPrimitiveType.
/// - `Constant` A constant value. Has the following additional keys:
/// - `value` The constant value, shared across all values of the schema.
/// \see value.h. \remark The schema is derived from the value.
/// - `List` A list of values. Has the following additional keys:
/// - `schema` The schema of the values in the list.
/// - `Map` A map of key-value pairs. Has the following additional keys:
/// - `key_schema` The schema of the keys.
/// - `value_schema` The schema of the values.
/// - `Tuple` A tuple of values. Has the following additional keys:
/// - `schemas` The schemas of the values in the tuple.
struct IkarusSchema;
/// \brief The type of primitive data.
enum IkarusValuePrimitiveType {
/// \brief A boolean.
IkarusValuePrimitiveType_Toggle = 1,
/// \brief A 64-bit floating point number.
IkarusValuePrimitiveType_Number = 2,
/// \brief An arbitrary length string.
IkarusValuePrimitiveType_Text = 3
};
/// \brief The type of schema.
enum IkarusValueSchemaType {
/// \brief A primitive value. \see IkarusPrimitiveType
IkarusValueSchemaType_Primitive = 1,
/// \brief A homogeneous list of values.
IkarusValueSchemaType_List = 2,
/// \brief A mapping from Value->Value.
IkarusValueSchemaType_Map = 3,
/// \brief A heterogeneous list of values.
IkarusValueSchemaType_Tuple = 4
};
IKARUS_END_HEADER

109
include/ikarus/values/text_value.h
View file

@ -1,109 +0,0 @@
#pragma once
/// \file text_value.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/values/value_cardinality.h>
/// \addtogroup values Values
/// @{
IKARUS_BEGIN_HEADER
/// \brief A numeric value. For example "Age" or "Height".
struct IkarusTextValue;
/// \brief Creates an empty text value.
/// \details If the cardinality is "Single", the value will be initialized with 0.0.
/// \param cardinality The cardinality of the value.
/// \param error_out \see errors.h
/// \return The value or null if an error occurs.
IKA_API IkarusTextValue * ikarus_text_value_create(IkarusValueCardinality cardinality, IkarusErrorData * error_out);
/// \brief Fetches the underlying data of a text value at a specific index.
/// \param value The text value.
/// \pre \li Must not be null.
/// \param idx The index of the data to fetch.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
/// \return The underlying data or NaN if an error occurs.
IKA_API char const * ikarus_text_value_get(IkarusTextValue const * value, size_t idx, IkarusErrorData * error_out);
/// \brief Fetches the size of the underlying data of a text value.
/// \param value The text value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The size of the underlying data or 0 if an error occurs.
IKA_API size_t ikarus_text_value_get_size(IkarusTextValue const * value, IkarusErrorData * error_out);
/// \brief Sets the data of a text value at a specific index.
/// \param value The text value.
/// \pre \li Must not be null.
/// \param idx The index of the data to set.
/// \pre \li Must be less than the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_text_value_set(IkarusTextValue * value, size_t idx, char const * new_data, IkarusErrorData * error_out);
/// \brief Inserts a data into a text value.
/// \param value The text value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to insert.
/// \pre \li Must be less than or equal to the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_text_value_insert(IkarusTextValue * value, size_t idx, char const * new_data, IkarusErrorData * error_out);
/// \brief Removes a data from a text value.
/// \param value The text value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to remove.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
IKA_API void ikarus_text_value_remove(IkarusTextValue * value, size_t idx, IkarusErrorData * error_out);
/// \brief Clears a text value.
/// \param value The text value.
/// \pre \li Cardinality must be "Multiple".
/// \param error_out \see errors.h
IKA_API void ikarus_text_value_clear(IkarusTextValue * value, IkarusErrorData * error_out);
/// \brief Converts a text value to a string.
/// \param value The text value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted string.
/// \remark Must be freed with #ikarus_free.
IKA_API char const * ikarus_text_value_to_string(IkarusTextValue const * value, IkarusErrorData * error_out);
/// \brief Checks if two values are equal.
/// \param lhs The left hand side value.
/// \pre \li Must not be null.
/// \param rhs The right hand side value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return True if the values' data are equal, false otherwise.
IKA_API bool ikarus_text_value_is_equal(IkarusTextValue const * lhs, IkarusTextValue const * rhs, IkarusErrorData * error_out);
/// \brief Creates a copy of a text value.
/// \param value The value to copy.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The copied value.
IKA_API IkarusTextValue * ikarus_text_value_copy(IkarusTextValue const * value, IkarusErrorData * error_out);
/// \brief Converts a text value to an entity value.
/// \param value The text value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted entity value.
/// \remark This is the same pointer, so freeing it implies freeing the original value.
IKA_API struct IkarusValueData * ikarus_text_value_to_value(IkarusTextValue * value, IkarusErrorData * error_out);
IKARUS_END_HEADER
/// @}

109
include/ikarus/values/toggle_value.h
View file

@ -1,109 +0,0 @@
#pragma once
/// \file toggle_value.h
/// \author Folling <folling@ikarus.world>
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/values/value_cardinality.h>
/// \addtogroup values Values
/// @{
IKARUS_BEGIN_HEADER
/// \brief A numeric value. For example "Age" or "Height".
struct IkarusToggleValue;
/// \brief Creates an empty toggle value.
/// \details If the cardinality is "Single", the value will be initialized with 0.0.
/// \param cardinality The cardinality of the value.
/// \param error_out \see errors.h
/// \return The value or null if an error occurs.
IKA_API IkarusToggleValue * ikarus_toggle_value_create(IkarusValueCardinality cardinality, IkarusErrorData * error_out);
/// \brief Fetches the underlying data of a toggle value at a specific index.
/// \param value The toggle value.
/// \pre \li Must not be null.
/// \param idx The index of the data to fetch.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
/// \return The underlying data or NaN if an error occurs.
IKA_API bool ikarus_toggle_value_get(IkarusToggleValue const * value, size_t idx, IkarusErrorData * error_out);
/// \brief Fetches the size of the underlying data of a toggle value.
/// \param value The toggle value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The size of the underlying data or 0 if an error occurs.
IKA_API size_t ikarus_toggle_value_get_size(IkarusToggleValue const * value, IkarusErrorData * error_out);
/// \brief Sets the data of a toggle value at a specific index.
/// \param value The toggle value.
/// \pre \li Must not be null.
/// \param idx The index of the data to set.
/// \pre \li Must be less than the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_toggle_value_set(IkarusToggleValue * value, size_t idx, bool new_data, IkarusErrorData * error_out);
/// \brief Inserts a data into a toggle value.
/// \param value The toggle value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to insert.
/// \pre \li Must be less than or equal to the size of the value.
/// \param new_data The new data.
/// \param error_out \see errors.h
IKA_API void ikarus_toggle_value_insert(IkarusToggleValue * value, size_t idx, bool new_data, IkarusErrorData * error_out);
/// \brief Removes a data from a toggle value.
/// \param value The toggle value.
/// \pre \li Must not be null.
/// \pre \li Cardinality must be "Multiple".
/// \param idx The index of the data to remove.
/// \pre \li Must be less than the size of the value.
/// \param error_out \see errors.h
IKA_API void ikarus_toggle_value_remove(IkarusToggleValue * value, size_t idx, IkarusErrorData * error_out);
/// \brief Clears a toggle value.
/// \param value The toggle value.
/// \pre \li Cardinality must be "Multiple".
/// \param error_out \see errors.h
IKA_API void ikarus_toggle_value_clear(IkarusToggleValue * value, IkarusErrorData * error_out);
/// \brief Converts a toggle value to a string.
/// \param value The toggle value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted string.
/// \remark Must be freed with #ikarus_free.
IKA_API char const * ikarus_toggle_value_to_string(IkarusToggleValue const * value, IkarusErrorData * error_out);
/// \brief Checks if two values are equal.
/// \param lhs The left hand side value.
/// \pre \li Must not be null.
/// \param rhs The right hand side value.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return True if the values' data are equal, false otherwise.
IKA_API bool ikarus_toggle_value_is_equal(IkarusToggleValue const * lhs, IkarusToggleValue const * rhs, IkarusErrorData * error_out);
/// \brief Creates a copy of a toggle value.
/// \param value The value to copy.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The copied value.
IKA_API IkarusToggleValue * ikarus_toggle_value_copy(IkarusToggleValue const * value, IkarusErrorData * error_out);
/// \brief Converts a toggle value to an entity value.
/// \param value The toggle value to convert.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The converted entity value.
/// \remark This is the same pointer, so freeing it implies freeing the original value.
IKA_API struct IkarusValueData * ikarus_toggle_value_to_value(IkarusToggleValue * value, IkarusErrorData * error_out);
IKARUS_END_HEADER
/// @}

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

@ -1,61 +1,26 @@
#pragma once
/// \file value.h
/// \author Folling <folling@ikarus.world>
/// \defgroup values Values
/// \brief Values are data in entities.
/// \details An entity is made up of any number of values.
/// Each value defines a certain aspect of an entity.
/// Values have a name, a type, and some data.
/// Examples of values would be:
/// - Is Dead (Toggle)
/// - Age (Number)
/// - ISBN (Text)
///
/// Values are either single or multiple.
/// We call this property "Cardinality" (\see IkarusValueCardinality)
/// because it's really hard to find a simpler name.
/// Each piece of data within a value is called a "datapoint".
/// Single values have exactly one datapoint, multiple values have any number of
/// datapoints. For example "Age" would be singular, while "Nicknames" would be
/// multiple. The type is unaffected by this. A pendant in programming languages
/// would be a List<T>. Note that all values are stored as a list of items,
/// even if the value is singular. Single values effectively act as a list with
/// one element. This is enforced by the API at runtime.
///
/// For a comprehensive list of value types, see \ref IkarusValueType.
/// @{
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
/// \file value.h
/// \author Folling <mail@folling.io>
/// \defgroup entities Entities
/// \brief Entities are the core building blocks of Ikarus.
IKARUS_BEGIN_HEADER
/// \brief The common type for all value data.
struct IkarusValue;
/// \brief Visits an entity value,
/// calling the appropriate function for the value's type.
/// \param value The entity value to visit.
/// \pre \li Must not be null.
/// \param toggle_visitor The function to call if the value is a toggle value.
/// \remark Skipped if null.
/// \param number_visitor The function to call if the value is a number value.
/// \remark Skipped if null.
/// \param text_visitor The function to call if the value is a text value.
/// \remark Skipped if null.
/// \param data The data passed to the visitor functions.
/// \param error_out \see errors.h
IKA_API void ikarus_value_visit(
IkarusValue * value,
void (*toggle_visitor)(struct IkarusToggleValue *, void *),
void (*number_visitor)(struct IkarusNumberValue *, void *),
void (*text_visitor)(struct IkarusTextValue *, void *),
void * data,
IkarusErrorData * error_out
);
/// \brief Values are data containers for entities.
/// \details Values are flexible enough to store any kind of data. They are
/// akin to objects in programming languages.
/// Each value has a schema that defines the type of the value. \see schema.h
/// They also store data appropriate for the schema.
///
/// Given the complexity of values, they are transferred as json.
/// The json representation of a value is a map with the following keys:
/// - `schema`: The schema of the value. \see schema.h.
/// - `data`: The data of the value. \see data.h.
IKARUS_END_HEADER
/// @}

23
include/ikarus/values/value_cardinality.h
View file

@ -1,23 +0,0 @@
#pragma once
/// \file value_cardinality.h
/// \author Folling <folling@ikarus.world>
/// \addtogroup values Values
/// @{
#include <ikarus/macros.h>
IKARUS_BEGIN_HEADER
/// \brief The cardinality of a value.
enum IkarusValueCardinality {
/// \brief Only contains one datapoint
IkarusValueCardinality_Single,
/// \brief Contains any number of datapoints
IkarusValueCardinality_List
};
IKARUS_END_HEADER
/// @}

198
include/ikarus/values/value_type.h
View file

@ -1,198 +0,0 @@
#pragma once
/// \file value_schema.h
/// \author Folling <folling@ikarus.world>
/// \addtogroup values Values
/// @{
#include <ikarus/errors.h>
#include <ikarus/macros.h>
#include <ikarus/stdtypes.h>
IKARUS_BEGIN_HEADER
/// \brief Layouts define the structure and constraints of values.
/// \details Ikarus lets you define any schema for values and add constraints to them.
/// These schemas are assembled hierarchical and are akin to JSON schemas.
/// Layouts may be arbitrarily nested and combined e.g.:
/// Combination<List<Text>, Number, Complex<"Foo":Toggle,"Bar":Text>
struct IkarusValueLayout;
/// \brief A fixed datapoint with a fixed layout.
/// Example: Age: Union<Number, Constant<Text, "Dead">>
struct IkarusValueLayoutConstant;
/// \brief A singular datapoint with one of a list of layouts.
/// Example: ChestReward: Combination<Item, Gold, Mimic>
struct IkarusValueLayoutCombination;
/// \brief A collection of datapoints with a homogenous layout.
/// Example: Friends: List<Character>
struct IkarusValueLayoutList;
/// \brief A collection of nameable datapoints with heterogeneous layouts.
/// Example: GeoLocation: Complex<"Latitude":Number, "Longitude":Number>
struct IkarusValueLayoutComplex;
/// \brief Defines the type of datapoints.
enum IkarusValueDataType {
/// \brief Boolean datapoints
/// Example: Is the character alive? Yes
Toggle,
/// \brief Numeric datapoints
/// Example: How much does the character weigh? 57kg
Number,
/// \brief Textual datapoints
/// Example: What is the character's maiden name? Sandra
Text,
/// \brief A colour datapoint
/// Example: What colours make up the nation's flag? White/Pink/Blue.
/// \remark Not yet implemented
Colour,
/// \brief A date/time datapoint, interfacing with the calendar and timeline feature.
/// Example: When was the city founded? 12th of January 233 at 2:11
/// \remark Not yet implemented
Time,
/// \brief A location datapoint, interfacing with the map feature.
/// Example: Where is the city situated? 12.345, 67.890
/// \remark Not yet implemented
Location,
/// \brief An enum-esque datapoint
/// Example: Of which rarity is the weapon? Normal/Rare/Legendary
/// \remark Not yet implemented
Choice,
/// \brief A datapoint linking to some other object in Ikarus
/// Example: Who wrote this hymn? Peter Parker
/// \remark Not yet implemented
Reference
};
/// \brief Stores either a schema or a datatype
struct IkarusValueSchema;
/// \see ikarus_value_schema_from_layout_const
IkarusValueSchema * ikarus_value_schema_from_layout(
IkarusValueLayout * layout,
IkarusErrorData * error_out
);
/// \brief Creates a value schema from a layout.
/// \param layout The layout to create the schema from.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The created schema or null if an error occurs.
IkarusValueSchema const * ikarus_value_schema_from_layout_const(
IkarusValueLayout const * layout,
IkarusErrorData * error_out
);
/// \brief Creates a value schema from a datatype.
/// \param type The datatype to create the schema from.
/// \param error_out \see errors.h
/// \return The created schema or null if an error occurs.
IkarusValueSchema * ikarus_value_schema_from_data_type(
IkarusValueDataType type,
IkarusErrorData * error_out
);
/// \brief Frees a value schema.
/// \param schema The schema to free.
/// \pre \li Must not be null.
/// \remark Must not be accessed after freeing.
void ikarus_value_schema_free(IkarusValueSchema * schema);
/// \see ikarus_value_schema_visit_const
void ikarus_value_schema_visit(
IkarusValueSchema * schema,
void (*layout_visitor)(IkarusValueLayout * layout),
void (*data_type_visitor)(IkarusValueDataType type),
IkarusErrorData * error_out
);
/// \brief Visits a value schema.
/// \param schema The schema to visit.
/// \pre \li Must not be null.
/// \param layout_visitor The function to call if the schema is a layout. Skipped if null.
/// \param data_type_visitor The function to call if the schema is a datatype. Skipped if null.
void ikarus_value_schema_visit_const(
IkarusValueSchema const * schema,
void (*layout_visitor)(IkarusValueLayout const * layout),
void (*data_type_visitor)(IkarusValueDataType type),
IkarusErrorData * error_out
);
/// \brief Creates a constant layout.
/// \param schema The schema of the value.
/// \pre \li Must not be null.
/// \param value The value of the constant.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
IkarusValueLayoutConstant * ikarus_value_layout_constant_create(
IkarusValueSchema * schema,
struct IkarusValue * value,
IkarusErrorData * error_out
);
/// \brief Gets the underyling schema of a constant layout.
/// \param layout The layout to get the underyling schema of.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The underlying schema of the layout or null if an error occurs.
IkarusValueSchema const * ikarus_value_layout_constant_get_underyling_schema(
IkarusValueLayoutConstant const * layout,
IkarusErrorData * error_out
);
/// \brief Gets the underyling value of a constant layout.
/// \param layout The layout to get the underyling value of.
/// \pre \li Must not be null.
/// \param error_out \see errors.h
/// \return The underlying value of the layout or null if an error occurs.
struct IkarusValue const * ikarus_value_layout_constant_get_underlying_value(
IkarusValueLayoutConstant const * layout,
IkarusErrorData * error_out
);
/// \brief Creates a combination layout.
/// \param schemas The schemas of the values.
/// \pre \li Must not be null.
/// \param schemas_size The number of schemas.
/// \param error_out \see errors.h
/// \return The created layout or null if an error occurs.
/// \remark The schemas are copied.
IkarusValueLayoutCombination * ikarus_value_layout_combination_create(
IkarusValueSchema * schemas,
size_t schemas_size,
IkarusErrorData * error_out
);
void ikarus_value_layout_combination_get_schemas(
IkarusValueLayoutCombination const * layout,
IkarusValueSchema ** schemas_out,
size_t * schemas_size_out,
IkarusErrorData * error_out
);
size_t ikarus_value_layout_combination_get_schemas_count(
IkarusValueLayoutCombination const * layout,
IkarusErrorData * error_out
);
IkarusValueLayoutList * ikarus_value_layout_list_create(
IkarusValueSchema * schema,
IkarusErrorData * error_out
);
IkarusValueLayoutComplex * ikarus_value_layout_complex_create(
IkarusValueSchema * schemas,
size_t schemas_size,
IkarusErrorData * error_out
);
IkarusValueLayoutComplex * ikarus_value_layout_complex_create_named(
IkarusValueSchema * schemas,
char const ** names,
size_t schemas_size,
IkarusErrorData * error_out
);
IKARUS_END_HEADER
/// @}

6
include/module.modulemap
View file

@ -1,6 +0,0 @@
module ikarus {
header "ikarus/persistence/project.h"
header "ikarus/objects/entity.h"
header "ikarus/objects/blueprint.h"
export *
}

49
src/ikarus/errors.cpp
View file

@ -1,31 +1,62 @@
#include "ikarus/errors.h"
#include <cstddef>
#include <ikarus/errors.hpp>
void safe_strcpy(
std::string_view const src,
char * dest,
std::size_t const dest_size
) {
int i = 0;
for (; i < dest_size - 1; ++i) {
if (src[i] == '\0') {
break;
}
dest[i] = src[i];
}
dest[i] = '\0';
}
char const * ikarus_get_error_info_name(IkarusErrorInfo info) {
switch (info) {
case IkarusErrorInfo_None: return "None";
case IkarusErrorInfo_Client_Misuse: return "Client::Misuse";
case IkarusErrorInfo_Client_InvalidInput: return "Client::InvalidInput";
case IkarusErrorInfo_Client_NonExistent: return "Client::NonExistent";
case IkarusErrorInfo_Client_InvalidFormat: return "Client::InvalidFormat";
case IkarusErrorInfo_Client_ConstraintViolated: return "Client::ConstraintViolated";
case IkarusErrorInfo_Client_ConstraintViolated:
return "Client::ConstraintViolated";
case IkarusErrorInfo_Filesystem_NotFound: return "Filesystem::NotFound";
case IkarusErrorInfo_Filesystem_AlreadyExists: return "Filesystem::AlreadyExists";
case IkarusErrorInfo_Filesystem_MissingPermissions: return "Filesystem::MissingPermissions";
case IkarusErrorInfo_Filesystem_InsufficientSpace: return "Filesystem::InsufficientSpace";
case IkarusErrorInfo_Filesystem_InvalidPath: return "Filesystem::InvalidPath";
case IkarusErrorInfo_Filesystem_AlreadyExists:
return "Filesystem::AlreadyExists";
case IkarusErrorInfo_Filesystem_MissingPermissions:
return "Filesystem::MissingPermissions";
case IkarusErrorInfo_Filesystem_InsufficientSpace:
return "Filesystem::InsufficientSpace";
case IkarusErrorInfo_Filesystem_InvalidPath:
return "Filesystem::InvalidPath";
case IkarusErrorInfo_Database_ConnectionFailed: return "Database::ConnectionFailed";
case IkarusErrorInfo_Database_ConnectionFailed:
return "Database::ConnectionFailed";
case IkarusErrorInfo_Database_QueryFailed: return "Database::QueryFailed";
case IkarusErrorInfo_Database_MigrationFailed: return "Database::MigrationFailed";
case IkarusErrorInfo_Database_MigrationFailed:
return "Database::MigrationFailed";
case IkarusErrorInfo_Database_InvalidState: return "Database::InvalidState";
case IkarusErrorInfo_OS_SystemCallFailed: return "OS::SystemCallFailed";
case IkarusErrorInfo_OS_InvalidReturnValue: return "OS::InvalidReturnValue";
case IkarusErrorInfo_OS_InsufficientMemory: return "OS::InsufficientMemory";
case IkarusErrorInfo_LibIkarus_InvalidState: return "LibIkarus::InvalidState";
case IkarusErrorInfo_LibIkarus_CannotPerformOperation: return "LibIkarus::CannotPerformOperation";
case IkarusErrorInfo_LibIkarus_InvalidState:
return "LibIkarus::InvalidState";
case IkarusErrorInfo_LibIkarus_CannotPerformOperation:
return "LibIkarus::CannotPerformOperation";
case IkarusErrorInfo_LibIkarus_Timeout: return "LibIkarus::Timeout";
default: return "Invalid";

191
src/ikarus/errors.hpp
View file

@ -1,23 +1,23 @@
#pragma once
#include <string_view>
#include <type_traits>
#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];
}
}
void safe_strcpy(
std::string_view const src,
char * dest,
size_t const dest_size
);
#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); \
safe_strcpy( \
msg, \
static_cast<char *>(error_out->message), \
IKARUS_ERROR_DATA_MAX_MESSAGE_LIMIT \
); \
error_out->info = err_info; \
}
@ -31,50 +31,139 @@ inline void safe_strcpy(char * dest, std::string_view src, size_t dest_size) {
return ret; \
}
#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( \
fmt::runtime(msg), \
std::move(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( \
fmt::runtime(msg), \
std::move(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( \
fmt::runtime(msg), \
std::move(var_name).unwrap_error() \
), \
err_info \
); \
return var_name; \
} \
value = std::move(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(fmt::runtime(msg), var_name.unwrap_error()), \
err_info \
); \
return ret; \
} \
value = std::move(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_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_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_FAIL_IF_NAME_INVALID(name, ret) \
IKARUS_FAIL_IF_NULL(name, ret); \
IKARUS_FAIL_IF( \
cppbase::is_empty_or_blank(name), \
ret, \
#name " must not be empty", \
IkarusErrorInfo_Client_InvalidInput \
);
#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_NOT_EXIST(object, ret) \
IKARUS_VTRYRV_OR_FAIL( \
auto exists, \
ret, \
fmt::format( \
"failed to check if {} exists", \
std::remove_cvref_t<decltype(*object)>::object_name \
), \
IkarusErrorInfo_Database_QueryFailed, \
object->project->db->query_one<bool>( \
fmt::format( \
"SELECT EXISTS(SELECT 1 FROM `{}` WHERE `id` = ?)", \
std::remove_cvref_t<decltype(*object)>::table_name \
), \
object->id \
) \
); \
\
IKARUS_FAIL_IF( \
!exists, \
ret, \
fmt::format( \
"{} doesn't exist", \
std::remove_cvref_t<decltype(*object)>::object_name \
), \
IkarusErrorInfo_Client_NonExistent \
)

163
src/ikarus/objects/blueprint.cpp
View file

@ -1,168 +1,5 @@
#include "ikarus/objects/blueprint.h"
#include <cppbase/logger.hpp>
#include <cppbase/result.hpp>
#include <cppbase/strings.hpp>
#include <ikarus/errors.hpp>
#include <ikarus/objects/blueprint.hpp>
#include <ikarus/objects/entity.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property.hpp>
#include <ikarus/objects/util.hpp>
#include <ikarus/persistence/project.hpp>
#include <ikarus/values/value_type.h>
IkarusBlueprint::IkarusBlueprint(IkarusProject * project, int64_t id):
IkarusObject{project, id} {}
std::string_view IkarusBlueprint::get_table_name() const noexcept {
return "blueprints";
}
IkarusBlueprint * ikarus_blueprint_create(struct IkarusProject * project, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
IKARUS_VTRYRV_OR_FAIL(
int64_t const id,
nullptr,
"failed to create blueprint: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->transact([name](auto * db) -> cppbase::Result<int64_t, sqlitecpp::TransactionError> {
TRY(db->execute("INSERT INTO `blueprints`(`name`) VALUES(?)", name));
return cppbase::ok(db->last_insert_rowid());
})
);
return project->get_blueprint(id);
}
void ikarus_blueprint_delete(IkarusBlueprint * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to delete blueprint: {}",
IkarusErrorInfo_Database_QueryFailed,
blueprint->project->db->execute("DELETE FROM `blueprints` WHERE `id` = ?", blueprint->id)
);
blueprint->project->uncache(blueprint);
}
int64_t ikarus_blueprint_get_id(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
return ikarus::util::object_get_id(blueprint, error_out);
}
IkarusProject * ikarus_blueprint_get_project(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
return ikarus::util::object_get_project(blueprint, error_out);
}
char const * ikarus_blueprint_get_name(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
return ikarus::util::object_get_name(blueprint, error_out);
}
void ikarus_blueprint_set_name(IkarusBlueprint * blueprint, char const * name, IkarusErrorData * error_out) {
ikarus::util::object_set_name(blueprint, name, error_out);
}
void ikarus_blueprint_get_properties(
IkarusBlueprint const * blueprint,
struct IkarusProperty ** properties_out,
size_t properties_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(blueprint, );
IKARUS_FAIL_IF_OBJECT_MISSING(blueprint, );
IKARUS_FAIL_IF_NULL(properties_out, );
if (properties_out_size == 0) {
return;
}
std::tuple<int64_t, IkarusValueType> ids_and_types[properties_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch blueprint properties from database: {}",
IkarusErrorInfo_Database_QueryFailed,
blueprint->project->db->query_many_buffered<int64_t, IkarusValueType>(
"SELECT `id` FROM `properties` WHERE `blueprint` = ?",
ids_and_types,
properties_out_size,
blueprint->id
)
)
for (size_t i = 0; i < properties_out_size; ++i) {
auto [id, type] = ids_and_types[i];
properties_out[i] = blueprint->project->get_property(id, type);
}
}
size_t ikarus_blueprint_get_property_count(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(blueprint, 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 `blueprint` = ?", blueprint->id)
);
return ret;
}
void ikarus_blueprint_get_linked_entities(
IkarusBlueprint const * blueprint,
struct IkarusEntity ** entities_out,
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;
}
int64_t ids[entities_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch blueprint linked entities from database: {}",
IkarusErrorInfo_Database_QueryFailed,
blueprint->project->db->query_many_buffered<int64_t>(
"SELECT `entity` FROM `entity_blueprint_links` WHERE `blueprint` = ?",
ids,
entities_out_size,
blueprint->id
)
)
for (size_t i = 0; i < entities_out_size; ++i) {
entities_out[i] = blueprint->project->get_entity(ids[i]);
}
}
size_t ikarus_blueprint_get_linked_entity_count(IkarusBlueprint const * blueprint, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(blueprint, 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(`entity`) FROM `entity_blueprint_links` WHERE `blueprint` = ?", blueprint->id)
);
return ret;
}

28
src/ikarus/objects/blueprint.hpp
View file

@ -1,19 +1,23 @@
#pragma once
#include <ikarus/objects/object.hpp>
#include <string>
struct IkarusBlueprint : public IkarusObject {
public:
IkarusBlueprint(struct IkarusProject * project, int64_t id);
struct IkarusBlueprint {
consteval static inline auto OBJECT_NAME() -> std::string_view {
return "blueprint";
}
IkarusBlueprint(IkarusBlueprint const &) = default;
IkarusBlueprint(IkarusBlueprint &&) = default;
consteval static inline auto TABLE_NAME() -> std::string_view {
return "blueprints";
}
IkarusBlueprint & operator=(IkarusBlueprint const &) = default;
IkarusBlueprint & operator=(IkarusBlueprint &&) = default;
IkarusBlueprint(
struct IkarusProject * project,
int64_t id,
std::string_view name
);
~IkarusBlueprint() override = default;
public:
std::string_view get_table_name() const noexcept override;
struct IkarusProject * project;
int64_t id;
std::string name;
};

523
src/ikarus/objects/entity.cpp
View file

@ -1,488 +1,171 @@
#include "ikarus/objects/entity.h"
#include <cppbase/strings.hpp>
#include "entity.hpp"
#include <ikarus/errors.h>
#include <ikarus/errors.hpp>
#include <ikarus/objects/blueprint.hpp>
#include <ikarus/objects/entity.hpp>
#include <ikarus/objects/properties/property.hpp>
#include <ikarus/objects/util.hpp>
#include <ikarus/objects/entity.h>
#include <ikarus/persistence/project.hpp>
#include <ikarus/values/entity_property_value.hpp>
#include <ikarus/values/value.hpp>
#include <ikarus/values/value_type.h>
IkarusEntity::IkarusEntity(IkarusProject * project, int64_t id):
IkarusObject{project, id} {}
std::string_view IkarusEntity::get_table_name() const noexcept {
return "entities";
}
IkarusEntity::IkarusEntity(
struct IkarusProject * project,
int64_t id,
std::string_view name
):
project{project},
id{id},
name{name} {}
IkarusEntity * ikarus_entity_create(
struct IkarusProject * project,
char const * name,
IkarusEntityCreateFlags flags,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
IKARUS_VTRYRV_OR_FAIL(
int64_t const id,
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to create entity: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->transact(
[name](auto * db
) -> cppbase::Result<int64_t, sqlitecpp::TransactionError> {
TRY(db->execute(
"INSERT INTO `entities`(`name`) VALUES(?, ?)",
name
));
return cppbase::ok(db->last_insert_rowid());
}
)
project->db->execute("INSERT INTO `entities`(`name`) VALUES(?)", name)
);
return project->get_entity(id);
auto const id = project->db->last_insert_rowid();
return new IkarusEntity{project, id, name};
}
void ikarus_entity_delete(IkarusEntity * entity, IkarusErrorData * error_out) {
void ikarus_entity_delete(
IkarusEntity * entity,
IkarusEntityDeleteFlags flags,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NOT_EXIST(entity, );
IKARUS_FAIL_IF_NULL(entity->project, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to delete entity: {}",
"failed to delete entity: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db
->execute("DELETE FROM `entities` WHERE `id` = ?", entity->id)
);
entity->project->uncache(entity);
delete entity;
}
int64_t
ikarus_entity_get_id(IkarusEntity const * entity, IkarusErrorData * error_out) {
return ikarus::util::object_get_id(entity, error_out);
}
IkarusProject * ikarus_entity_get_project(
IkarusEntity const * entity,
IkarusEntity * ikarus_entity_copy(
IkarusEntity * entity,
IkarusEntityCopyFlags flags,
IkarusErrorData * error_out
) {
return ikarus::util::object_get_project(entity, error_out);
IKARUS_FAIL_IF_NULL(entity, nullptr);
IKARUS_FAIL_IF_NOT_EXIST(entity, nullptr);
IKARUS_FAIL_IF_NULL(entity->project, nullptr);
IKARUS_VTRYRV_OR_FAIL(
auto id,
nullptr,
"failed to copy entity: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->transact(
[entity](auto * db)
-> cppbase::Result<int64_t, sqlitecpp::TransactionError> {
TRY(entity->project->db->execute(
"INSERT INTO `entities`(`name`) VALUES(?)",
entity->name.data()
));
TRY(entity->project->db->execute(
"INSERT INTO `entity_values`(`entity`, `name`, `value`)"
" SELECT ?1, `name`, `value` FROM `entity_values` WHERE "
"`entity` = ?1",
entity->id
))
TRY(entity->project->db->execute(
"INSERT INTO `entity_property_values`("
" `entity`, "
" `property`,"
" `value`"
") "
"SELECT ?1, `property`, `value` FROM "
"`entity_property_values` "
"WHERE `entity` = ?1",
entity->id
))
TRY(entity->project->db->execute(
"INSERT INTO `entity_blueprint_links`(`entity`, "
"`blueprint`)"
"SELECT ?1, `property`, `value` FROM "
"`entity_property_values` "
"WHERE `entity` = ?1",
entity->id
))
return cppbase::ok(entity->project->db->last_insert_rowid());
}
)
);
return new IkarusEntity{entity->project, id, entity->name};
}
char const * ikarus_entity_get_name(
IkarusEntity const * entity,
IkarusErrorData * error_out
) {
return ikarus::util::object_get_name(entity, error_out);
IkarusProject *
ikarus_entity_get_project(IkarusEntity * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
IKARUS_FAIL_IF_NULL(entity->project, nullptr);
return entity->project;
}
char const *
ikarus_entity_get_name(IkarusEntity * entity, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
return entity->name.data();
}
void ikarus_entity_set_name(
IkarusEntity * entity,
char const * name,
IkarusErrorData * error_out
) {
ikarus::util::object_set_name(entity, name, error_out);
}
bool ikarus_entity_is_linked_to_blueprint(
IkarusEntity const * entity,
struct IkarusBlueprint const * blueprint,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, false);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, false);
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
)
)
return ret;
}
void ikarus_entity_link_to_blueprint(
IkarusEntity * entity,
struct IkarusBlueprint * blueprint,
IkarusEntitySetNameFlags flags,
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_FAIL_IF_NAME_INVALID(name, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to link entity to blueprint: {}",
"failed to set name for entity: {}",
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
)
);
IKARUS_TRYRV_OR_FAIL(
,
"unable to remove entity property values: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"DELETE FROM `entity_property_values` WHERE `entity` = ? AND "
"`property` IN (SELECT "
"`id` FROM `properties` WHERE `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;
}
int64_t 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<int64_t>(
"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(`blueprint`) FROM `entity_blueprint_links` WHERE "
"`entity` = ?",
"UPDATE `entities` SET `name` = ? WHERE `id` = ?",
name,
entity->id
)
);
return ret;
entity->name = name;
}
bool ikarus_entity_has_value(
IkarusEntity const * entity,
char const * name,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, false);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, false);
IKARUS_FAIL_IF_NAME_INVALID(name, false);
IKARUS_VTRYRV_OR_FAIL(
auto const has_value,
false,
"unable to check whether entity has value: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<bool>(
"SELECT EXISTS(SELECT 1 FROM `entity_values` WHERE `entity` = ? "
"AND `name` = ?)",
entity->id,
name
)
);
return has_value;
}
struct IkarusValue * ikarus_entity_get_value(
IkarusEntity const * entity,
char const * ikarus_entity_get_value(
IkarusEntity * entity,
char const * name,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(entity, nullptr);
IKARUS_FAIL_IF_VALUE_MISSING(entity, name, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
auto * value = fetch_value_from_db(
entity->project,
error_out,
"SELECT `value` FROM `entity_values` WHERE `entity` = ? AND `name` = ?",
entity->id,
name
);
IKARUS_FAIL_IF_ERROR(nullptr);
return value;
IKARUS_FAIL_IF_NULL(name, nullptr);
}
void ikarus_entity_set_value(
IkarusEntity * entity,
char const * name,
struct IkarusValue const * value,
char const * value,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_NAME_INVALID(name, );
IKARUS_FAIL_IF_NULL(name, );
IKARUS_FAIL_IF_NULL(value, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to set entity value: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"INSERT INTO `entity_values`(`entity`, `name`, `value`) VALUES(?1, "
"?2, ?3) ON "
"CONFLICT(`entity`, `name`) DO UPDATE SET `value` = ?3",
entity->id,
name,
boost::json::serialize(value->to_json())
)
);
}
void ikarus_entity_delete_value(
IkarusEntity * entity,
char const * name,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(entity, );
IKARUS_FAIL_IF_OBJECT_MISSING(entity, );
IKARUS_FAIL_IF_VALUE_MISSING(entity, name, );
IKARUS_FAIL_IF_NAME_INVALID(name, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to delete entity value: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"DELETE FROM `entity_values` WHERE `entity` = ? AND `name` = ?",
entity->id,
name
)
);
}
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);
// given that values are loaded lazily we can't just check
// `entity_property_values` here
IKARUS_VTRYRV_OR_FAIL(
auto const has_property,
false,
"unable to check whether entity has property: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<bool>(
"SELECT EXISTS(\n"
" SELECT 1\n"
" FROM `entity_blueprint_links`\n"
" JOIN `properties` ON `properties`.`blueprint` = "
"`entity_blueprint_links`.`blueprint`\n"
" WHERE `entity_blueprint_links`.`entity` = ? AND "
"`properties`.`id` = ?\n"
")",
entity->id,
property->id
)
)
return has_property;
}
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<int64_t, IkarusValueType> ids_and_types[properties_out_size];
// given that values are loaded lazily we can't just check
// `entity_property_values` here
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch properties from entity: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_many_buffered<int64_t, IkarusValueType>(
"SELECT `properties`.`id`, `properties`.`type`\n"
"FROM `entity_blueprint_links`\n"
"JOIN `properties` ON `properties`.`blueprint` = "
"`entity_blueprint_links`.`blueprint`\n"
"WHERE `entity_blueprint_links`.`entity` = ?\n",
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);
// given that values are loaded lazily we can't just check
// `entity_property_values` here
IKARUS_VTRYRV_OR_FAIL(
size_t const count,
0,
"unable to fetch property count from entity: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->query_one<int64_t>(
"SELECT COUNT(`properties`.`id`)\n"
"FROM `entity_blueprint_links`\n"
"JOIN `properties` ON `properties`.`blueprint` = "
"`entity_blueprint_links`.`blueprint`\n"
"WHERE `entity_blueprint_links`.`entity` = ?\n"
")",
entity->id
)
);
return count;
}
struct IkarusValue * ikarus_entity_get_property_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(\n"
" (\n"
" SELECT `value`\n"
" FROM `entity_property_values`\n"
" WHERE `entity` = ?1 AND `property` = ?2\n"
" ),\n"
" (SELECT `default_value` FROM `properties` WHERE `id` = ?2)\n"
")",
entity->id,
property->id
);
IKARUS_FAIL_IF_ERROR(nullptr);
return value;
}
void ikarus_entity_set_property_value(
IkarusEntity * entity,
struct IkarusProperty const * property,
struct IkarusValue * 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, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to set entity property value: {}",
IkarusErrorInfo_Database_QueryFailed,
entity->project->db->execute(
"INSERT INTO `entity_property_values`(`entity`, `property`, "
"`value`) VALUES(?1, ?2, "
"?3) ON CONFLICT(`entity`, `property`) DO UPDATE SET `value` = ?3",
entity->id,
property->id,
boost::json::serialize(value->to_json())
)
);
}

27
src/ikarus/objects/entity.hpp
View file

@ -1,19 +1,24 @@
#pragma once
#include <ikarus/objects/object.hpp>
#include <string>
#include <vector>
struct IkarusEntity : public IkarusObject {
public:
inline IkarusEntity(struct IkarusProject * project, int64_t id);
#include <ikarus/values/value.hpp>
IkarusEntity(IkarusEntity const &) = default;
IkarusEntity(IkarusEntity &&) = default;
struct IkarusEntity {
constinit static inline auto object_name = "entity";
constinit static inline auto table_name = "entities";
IkarusEntity & operator=(IkarusEntity const &) = default;
IkarusEntity & operator=(IkarusEntity &&) = default;
IkarusEntity(
struct IkarusProject * project,
int64_t id,
std::string_view name
);
~IkarusEntity() override = default;
struct IkarusProject * project;
int64_t id;
std::string name;
public:
std::string_view get_table_name() const noexcept override;
std::vector<std::pair<std::string_view, IkarusValue *>> values_ordered;
std::unordered_map<std::string, IkarusValue> values;
};

7
src/ikarus/objects/object.cpp
View file

@ -1,7 +0,0 @@
#include "object.hpp"
#include <ikarus/persistence/project.hpp>
IkarusObject::IkarusObject(IkarusProject * project, int64_t id):
project{project},
id{id} {}

36
src/ikarus/objects/object.hpp
View file

@ -1,36 +0,0 @@
#pragma once
#include <string_view>
class IkarusObject {
public:
IkarusObject(struct IkarusProject * project, int64_t id);
IkarusObject(IkarusObject const &) = default;
IkarusObject(IkarusObject &&) = default;
IkarusObject & operator=(IkarusObject const &) = default;
IkarusObject & operator=(IkarusObject &&) = default;
virtual ~IkarusObject() = default;
public:
virtual std::string_view get_table_name() const noexcept = 0;
public:
struct IkarusProject * project;
int64_t id;
};
#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);

32
src/ikarus/objects/properties/number_property.cpp
View file

@ -1,32 +0,0 @@
#include "number_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property_scope.hpp>
#include <ikarus/objects/properties/util.hpp>
#include <ikarus/values/value.hpp>
IkarusNumberProperty::IkarusNumberProperty(IkarusProject * project, int64_t id):
IkarusProperty{project, id, this} {}
IkarusNumberProperty * ikarus_number_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertyScope * 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);
}

14
src/ikarus/objects/properties/number_property.hpp
View file

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

143
src/ikarus/objects/properties/property.cpp
View file

@ -1,143 +0,0 @@
#include "property.hpp"
#include <cppbase/logger.hpp>
#include <ikarus/errors.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property_scope.hpp>
#include <ikarus/values/value_type.h>
#include <ikarus/objects/util.hpp>
#include <ikarus/persistence/project.hpp>
#include <ikarus/values/value.hpp>
IkarusProperty::IkarusProperty(IkarusProject * project, int64_t id, Data data):
IkarusObject{project, id},
data{data} {}
IKA_API void ikarus_property_delete(IkarusProperty * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
IKARUS_TRYRV_OR_FAIL(
,
"unable to delete property: {}",
IkarusErrorInfo_Database_QueryFailed,
property->project->db->execute("DELETE FROM `objects` WHERE `id` = ?", property->id)
);
property->project->uncache(property);
}
int64_t ikarus_property_get_id(IkarusProperty const * property, IkarusErrorData * error_out) {
return ikarus::util::object_get_id(property, error_out);
}
IkarusProject * ikarus_property_get_project(IkarusProperty const * property, IkarusErrorData * error_out) {
return ikarus::util::object_get_project(property, error_out);
}
char const * ikarus_property_get_name(IkarusProperty const * property, IkarusErrorData * error_out) {
return ikarus::util::object_get_name(property, error_out);
}
void ikarus_property_set_name(IkarusProperty * property, char const * name, IkarusErrorData * error_out) {
ikarus::util::object_set_name(property, name, error_out);
}
IkarusValueType ikarus_property_get_type(IkarusProperty const * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(property, IkarusValueType_Toggle);
IKARUS_FAIL_IF_OBJECT_MISSING(property, IkarusValueType_Toggle);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
IkarusValueType_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<IkarusValueType>(ret);
}
IkarusPropertyScope const * ikarus_property_get_scope(IkarusProperty const * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(property, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(property, nullptr);
IKARUS_VTRYRV_OR_FAIL(
auto const source,
nullptr,
"unable to fetch property source from database: {}",
IkarusErrorInfo_Database_QueryFailed,
property->project->db->query_one<int64_t>("SELECT `source` FROM `properties` WHERE `id` = ?", property->id)
);
switch (ikarus_id_get_object_type(source)) {
case IkarusObjectType_Blueprint: return new IkarusPropertyScope{property->project->get_blueprint(source)};
case IkarusObjectType_Entity: return new IkarusPropertyScope{property->project->get_entity(source)};
default:
IKARUS_FAIL(
nullptr,
fmt::format("invalid property source type: {}", ikarus_object_type_to_string(ikarus_id_get_object_type(source))),
IkarusErrorInfo_LibIkarus_InvalidState
);
}
}
IkarusValueData * ikarus_property_get_default_value(IkarusProperty const * property, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(property, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(property, nullptr);
return fetch_value_from_db(property->project, error_out, "SELECT `default_value` FROM `properties` WHERE `id` = ?", property->id);
}
void ikarus_property_visit(
IkarusProperty * property,
void (*toggle_property_visitor)(struct IkarusToggleProperty *, void *),
void (*number_property_visitor)(struct IkarusNumberProperty *, void *),
void (*text_property_visitor)(struct IkarusTextProperty *, void *),
void * data,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
std::visit(
cppbase::overloaded{
[toggle_property_visitor, data](IkarusToggleProperty * property) { toggle_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); }
},
property->data
);
}
void ikarus_property_visit_const(
IkarusProperty const * property,
void (*toggle_property_visitor)(struct IkarusToggleProperty const *, void *),
void (*number_property_visitor)(struct IkarusNumberProperty const *, void *),
void (*text_property_visitor)(struct IkarusTextProperty const *, void *),
void * data,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(property, );
IKARUS_FAIL_IF_OBJECT_MISSING(property, );
std::visit(
cppbase::overloaded{
[toggle_property_visitor, data](IkarusToggleProperty const * property) { toggle_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); }
},
property->data
);
}
// No existence checks here for performance reasons. All methods on IkarusObject perform this check anyway.
IkarusObject * ikarus_property_to_object(IkarusProperty * property) {
return static_cast<IkarusObject *>(property);
}
IkarusObject const * ikarus_property_to_object_const(IkarusProperty const * property) {
return static_cast<IkarusObject const *>(property);
}

29
src/ikarus/objects/properties/property.hpp
View file

@ -1,29 +0,0 @@
#pragma once
#include <variant>
#include <ikarus/objects/object.hpp>
struct IkarusProperty : public IkarusObject {
public:
using Data = std::variant<struct IkarusToggleProperty *, struct IkarusNumberProperty *, struct IkarusTextProperty *>;
public:
IkarusProperty(struct IkarusProject * project, int64_t id, Data data);
IkarusProperty(IkarusProperty const &) = default;
IkarusProperty(IkarusProperty &&) = default;
IkarusProperty & operator=(IkarusProperty const &) = default;
IkarusProperty & operator=(IkarusProperty &&) = default;
~IkarusProperty() override = default;
public:
inline std::string_view get_table_name() const noexcept override {
return "properties";
}
public:
Data data;
};

32
src/ikarus/objects/properties/text_property.cpp
View file

@ -1,32 +0,0 @@
#include "text_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property_scope.hpp>
#include <ikarus/objects/properties/util.hpp>
#include <ikarus/values/value.hpp>
IkarusTextProperty::IkarusTextProperty(IkarusProject * project, int64_t id):
IkarusProperty{project, id, this} {}
IkarusTextProperty * ikarus_text_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertyScope * 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);
}

14
src/ikarus/objects/properties/text_property.hpp
View file

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

32
src/ikarus/objects/properties/toggle_property.cpp
View file

@ -1,32 +0,0 @@
#include "toggle_property.hpp"
#include <cppbase/result.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property_scope.hpp>
#include <ikarus/objects/properties/util.hpp>
#include <ikarus/values/value.hpp>
IkarusToggleProperty::IkarusToggleProperty(IkarusProject * project, int64_t id):
IkarusProperty{project, id, this} {}
IkarusToggleProperty * ikarus_toggle_property_create(
struct IkarusProject * project,
char const * name,
struct IkarusPropertyScope * 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);
}

17
src/ikarus/objects/properties/toggle_property.hpp
View file

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

95
src/ikarus/objects/properties/util.hpp
View file

@ -1,95 +0,0 @@
#pragma once
#include <boost/type_index.hpp>
#include <cppbase/strings.hpp>
#include <ikarus/errors.hpp>
#include <ikarus/objects/properties/property.h>
#include <ikarus/objects/properties/property.hpp>
#include <ikarus/objects/properties/property_scope.hpp>
#include <ikarus/objects/util.hpp>
#include <ikarus/persistence/project.hpp>
#include <ikarus/values/value.hpp>
namespace ikarus::util {
template<typename T>
T * create_property(
struct IkarusProject * project,
char const * name,
struct IkarusPropertyScope * property_scope,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NULL(property_scope, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
IKARUS_VTRYRV_OR_FAIL(
int64_t const id,
nullptr,
"failed to create property: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->transact([name, property_scope](auto * db) -> cppbase::Result<int64_t, sqlitecpp::TransactionError> {
TRY(db->execute("INSERT INTO `objects`(`type`) VALUES(?)", IkarusObjectType_Property));
auto id = ikarus_id_from_data_and_type(db->last_insert_rowid(), IkarusObjectType_Property);
TRY(db->execute(
"INSERT INTO `properties`(`id`, `name`, `type`, `source`) VALUES(?, ?, ?, ?)",
id,
name,
T::PropertyType,
property_scope->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

15
src/ikarus/objects/property.cpp Normal file
View file

@ -0,0 +1,15 @@
#include "property.hpp"
#include <ikarus/errors.h>
#include <ikarus/errors.hpp>
#include <ikarus/objects/property.h>
#include <ikarus/persistence/project.hpp>
IkarusProperty::IkarusProperty(
struct IkarusProject * project,
int64_t id,
std::string_view name
):
project{project},
id{id},
name{name} {}

23
src/ikarus/objects/property.hpp Normal file
View file

@ -0,0 +1,23 @@
#pragma once
#include <string>
struct IkarusProperty {
consteval static inline auto OBJECT_NAME() -> std::string_view {
return "property";
}
consteval static inline auto TABLE_NAME() -> std::string_view {
return "properties";
}
IkarusProperty(
struct IkarusProject * project,
int64_t id,
std::string_view name
);
struct IkarusProject * project;
int64_t id;
std::string name;
};

63
src/ikarus/objects/util.hpp
View file

@ -1,63 +0,0 @@
#pragma once
#include <string_view>
#include <cppbase/strings.hpp>
#include <ikarus/errors.h>
#include <ikarus/errors.hpp>
#include <ikarus/persistence/project.hpp>
namespace ikarus::util {
template<typename O>
[[nodiscard]] int64_t object_get_id(O const * object, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(object, 0);
IKARUS_FAIL_IF_OBJECT_MISSING(object, 0);
return object->id;
}
template<typename O>
[[nodiscard]] IkarusProject * object_get_project(O const * object, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(object, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(object, nullptr);
return object->project;
}
template<typename O>
[[nodiscard]] char const * object_get_name(O const * object, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(object, nullptr);
IKARUS_FAIL_IF_OBJECT_MISSING(object, nullptr);
IKARUS_VTRYRV_OR_FAIL(
auto const ret,
nullptr,
fmt::runtime(fmt::format("unable to fetch {} name: {{}}", ikarus_object_type_to_string(ikarus_id_get_object_type(object->id)))),
IkarusErrorInfo_Database_QueryFailed,
object->project->db
->template query_one<std::string>(fmt::format("SELECT `name` FROM `{}` WHERE `id` = ?", object->get_table_name()), object->id)
);
return strdup(ret.data());
}
#define IKARUS_FAIL_IF_NAME_INVALID(name, ret) IKARUS_FAIL_IF_NULL(name, ret);
template<typename O>
void object_set_name(O * object, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(object, );
IKARUS_FAIL_IF_OBJECT_MISSING(object, );
IKARUS_FAIL_IF_NULL(name, );
IKARUS_FAIL_IF_NAME_INVALID(name, );
IKARUS_TRYRV_OR_FAIL(
,
fmt::runtime(fmt::format("unable to set {} name: {{}}", ikarus_object_type_to_string(ikarus_id_get_object_type(object->id)))),
IkarusErrorInfo_Database_QueryFailed,
object->project->db->execute(fmt::format("UPDATE `{}` SET `name` = ? WHERE `id` = ?", object->get_table_name()), name, object->id)
);
}
} // namespace ikarus::util

13
src/ikarus/persistence/migrations.hpp
View file

@ -1,7 +1,5 @@
#pragma once
#include <array>
#include <cppbase/assets.hpp>
#include <cppbase/result.hpp>
@ -9,7 +7,10 @@
namespace ikarus {
CPPBASE_ASSET(m0_initial_layout, "ikarus/persistence/migrations/m0_initial_layout.sql");
CPPBASE_ASSET(
m0_initial_layout,
"ikarus/persistence/migrations/m0_initial_layout.sql"
);
class Migration : public sqlitecpp::Migration {
public:
@ -27,7 +28,11 @@ public:
std::string_view sql;
};
#define DECLARE_MIGRATION(name) std::make_unique<ikarus::Migration>(static_cast<char const *>(name()), name##_size())
#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 = []() {

18
src/ikarus/persistence/migrations/m0_initial_layout.sql
View file

@ -6,13 +6,14 @@ CREATE TABLE `entities`
CREATE TABLE `entity_values`
(
`id` INTEGER PRIMARY KEY,
`entity` INTEGER NOT NULL REFERENCES `entities` (`id`) ON DELETE CASCADE,
`name` TEXT NOT NULL,
`type` INT NOT NULL,
`value` TEXT NOT NULL,
PRIMARY KEY (`entity`, `name`)
) WITHOUT ROWID, STRICT;
PRIMARY KEY (`id`),
UNIQUE (`entity`, `name`)
) STRICT;
CREATE TABLE `blueprints`
(
@ -25,14 +26,11 @@ CREATE TABLE `properties`
`id` INTEGER PRIMARY KEY,
`blueprint` INTEGER NOT NULL REFERENCES `blueprints` (`id`) ON DELETE CASCADE,
`name` TEXT NOT NULL,
`type` INT NOT NULL,
`cardinality` INT NOT NULL,
`schema` TEXT NOT NULL,
`default_value` TEXT NOT NULL,
`settings` TEXT NOT NULL
) STRICT;
CREATE INDEX `properties_type` ON `properties` (`type`);
CREATE TABLE `entity_blueprint_links`
(
`entity` INTEGER NOT NULL REFERENCES `entities` (`id`) ON DELETE CASCADE,
@ -43,9 +41,11 @@ CREATE TABLE `entity_blueprint_links`
CREATE TABLE `entity_property_values`
(
`id` INTEGER PRIMARY KEY,
`entity` INTEGER NOT NULL REFERENCES `entities` (`id`) ON DELETE CASCADE,
`property` INTEGER NOT NULL REFERENCES `properties` (`id`) ON DELETE CASCADE,
`value` TEXT NOT NULL,
PRIMARY KEY (`entity`, `property`)
) WITHOUT ROWID, STRICT;
PRIMARY KEY (`id`),
UNIQUE (`entity`, `property`)
) STRICT;

403
src/ikarus/persistence/project.cpp
View file

@ -1,83 +1,28 @@
#include "ikarus/persistence/project.h"
#include <cstdint>
#include <boost/filesystem.hpp>
#include <boost/uuid.hpp>
#include <cppbase/strings.hpp>
#include <ikarus/errors.h>
#include <ikarus/errors.hpp>
#include <ikarus/macros.h>
#include <ikarus/objects/blueprint.hpp>
#include <ikarus/objects/entity.hpp>
#include <ikarus/objects/properties/number_property.hpp>
#include <ikarus/objects/properties/property.hpp>
#include <ikarus/objects/properties/text_property.hpp>
#include <ikarus/objects/properties/toggle_property.hpp>
#include <ikarus/objects/util.hpp>
#include <ikarus/persistence/migrations.hpp>
#include <ikarus/persistence/project.hpp>
IkarusProject::IkarusProject(std::string_view name, std::string_view path, std::unique_ptr<sqlitecpp::Connection> && db):
name{name},
path{std::move(path)},
db{std::move(db)},
_blueprints{},
_properties{},
_entities{} {}
IkarusBlueprint * IkarusProject::get_blueprint(int64_t id) {
return get_cached_object<IkarusBlueprint>(id, this->_blueprints);
}
auto IkarusProject::uncache(IkarusBlueprint * blueprint) -> void {
remove_cached_object(blueprint, _blueprints);
}
auto IkarusProject::get_entity(int64_t id) -> IkarusEntity * {
return get_cached_object<IkarusEntity>(id, this->_entities);
}
auto IkarusProject::uncache(IkarusEntity * entity) -> void {
remove_cached_object(entity, _entities);
}
auto IkarusProject::get_property(int64_t id, IkarusValueType type) -> IkarusProperty * {
auto const iter = _properties.find(id);
if (iter == _properties.cend()) {
switch (type) {
case IkarusValueType_Toggle:
return _properties.emplace(id, std::make_unique<IkarusToggleProperty>(this, id)).first->second.get();
case IkarusValueType_Number:
return _properties.emplace(id, std::make_unique<IkarusNumberProperty>(this, id)).first->second.get();
case IkarusValueType_Text: return _properties.emplace(id, std::make_unique<IkarusTextProperty>(this, id)).first->second.get();
}
}
return iter->second.get();
}
auto IkarusProject::uncache(IkarusProperty * property) -> void {
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 && ec != boost::system::errc::no_such_file_or_directory,
nullptr,
fmt::format("unable to check whether path is occupied: {}", ec.message()),
IkarusErrorInfo_Filesystem_AlreadyExists
);
IKARUS_FAIL_IF(exists, nullptr, "path is already occupied", IkarusErrorInfo_Filesystem_AlreadyExists);
}
constexpr char const * DB_PROJECT_ID_KEY = "project_id";
constexpr char const * DB_PROJECT_NAME_KEY = "project_name";
auto create_impl(
std::string_view path,
std::string_view name,
IkarusErrorData * error_out
) -> std::unique_ptr<sqlitecpp::Connection> {
IKARUS_VTRYRV_OR_FAIL(
auto db,
nullptr,
@ -86,42 +31,133 @@ IkarusProject * ikarus_project_create(char const * path, char const * name, Ikar
sqlitecpp::Connection::open(path)
);
auto close_db = [&]() {
if (db) {
LOG_INFO("closing project db");
auto res = db->close();
if (res.is_error()) {
LOG_ERROR("failed to close project db: {}", res.unwrap_error());
};
}
};
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to migrate project db: {}",
IkarusErrorInfo_Database_MigrationFailed,
db->migrate(ikarus::MIGRATIONS)
db->migrate(ikarus::MIGRATIONS).on_error(close_db)
);
if (auto res = db->execute("INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)", DB_PROJECT_NAME_KEY, name); res.is_error()) {
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to set project id",
IkarusErrorInfo_Database_QueryFailed,
db->execute(
"INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)",
DB_PROJECT_ID_KEY,
boost::uuids::to_string(boost::uuids::random_generator()())
)
.on_error(close_db)
);
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to set project id",
IkarusErrorInfo_Database_QueryFailed,
db->execute(
"INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)",
DB_PROJECT_NAME_KEY,
name
)
.on_error(close_db)
);
return std::move(db);
}
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;
fs::remove(fs_path, ec);
bool const exists = boost::filesystem::exists(fs_path, ec);
IKARUS_FAIL_IF(
ec && ec != boost::system::errc::no_such_file_or_directory,
nullptr,
fmt::format(
"unable to check whether path is occupied: {}",
ec.message()
),
IkarusErrorInfo_Filesystem_AlreadyExists
);
IKARUS_FAIL_IF(
exists,
nullptr,
"path is already occupied",
IkarusErrorInfo_Filesystem_AlreadyExists
);
}
if (auto db = create_impl(fs_path.c_str(), name, error_out); !db) {
LOG_WARN("creating project failed, removing file at {}", path);
boost::system::error_code ec;
boost::filesystem::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
"failed to remove project db",
IkarusErrorInfo_Filesystem_MissingPermissions
);
IKARUS_FAIL(nullptr, "failed to insert project name into metadata: {}", IkarusErrorInfo_Database_QueryFailed);
}
IKARUS_FAIL(
nullptr,
"failed to insert project name into metadata: {}",
IkarusErrorInfo_Database_QueryFailed
);
return nullptr;
} else {
return new IkarusProject{name, path, std::move(db)};
}
}
IkarusProject * ikarus_project_create_in_memory(char const * name, IkarusErrorData * error_out) {
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,
IKARUS_FAIL_IF(
cppbase::is_empty_or_blank(name),
nullptr,
"failed to create project db in memory: {}",
IkarusErrorInfo_Database_ConnectionFailed,
sqlitecpp::Connection::open_in_memory()
"name must not be empty",
IkarusErrorInfo_Client_InvalidInput
);
if (auto db = create_impl(":memory:", name, error_out); !db) {
return nullptr;
} else {
IKARUS_TRYRV_OR_FAIL(
nullptr,
"failed to migrate project db: {}",
@ -133,15 +169,25 @@ IkarusProject * ikarus_project_create_in_memory(char const * name, IkarusErrorDa
nullptr,
"failed to insert project name into metadata: {}",
IkarusErrorInfo_Database_QueryFailed,
db->execute("INSERT INTO `metadata`(`key`, `value`) VALUES(?, ?)", DB_PROJECT_NAME_KEY, name)
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) {
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_FAIL_IF(
cppbase::is_empty_or_blank(path),
nullptr,
"path must not be empty",
IkarusErrorInfo_Client_InvalidInput
);
IKARUS_VTRYRV_OR_FAIL(
auto db,
@ -163,111 +209,89 @@ IkarusProject * ikarus_project_open(char const * path, IkarusErrorData * error_o
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)
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) {
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) {
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_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)
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,
char const * ikarus_project_get_path(
IkarusProject const * project,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(blueprints_out, );
IKARUS_FAIL_IF_NULL(project, nullptr);
if (blueprints_out_size == 0) {
return;
}
int64_t ids[blueprints_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch project blueprints from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_many_buffered<int64_t>("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;
return project->path.c_str();
}
void ikarus_project_get_entities(
IkarusProject * project,
struct IkarusEntity ** entities_out,
size_t entities_out_size,
struct IkarusProject const * project,
int64_t * ids_out,
uint64_t ids_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(entities_out, );
IKARUS_FAIL_IF_NULL(ids_out, );
if (entities_out_size == 0) {
if (ids_out == 0) {
return;
}
int64_t ids[entities_out_size];
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch project entities from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_many_buffered<int64_t>("SELECT `id` FROM `entities`", ids, entities_out_size)
project->db->query_many_buffered<int64_t>(
"SELECT `id` FROM `entities`",
ids_out,
ids_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 const * project, IkarusErrorData * error_out) {
size_t ikarus_project_get_entity_count(
IkarusProject const * project,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, 0);
IKARUS_VTRYRV_OR_FAIL(
@ -275,65 +299,50 @@ size_t ikarus_project_get_entity_count(IkarusProject const * project, IkarusErro
0,
"unable to fetch project entity count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_one<int64_t>("SELECT COUNT(*) FROM `entities`")
project->db->query_one<int64_t>("SELECT COUNT(`id`) FROM `entities`")
);
return ret;
}
struct IkarusEntity * get_entity_by_name(IkarusProject * project, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
void ikarus_project_get_blueprints(
struct IkarusProject const * project,
int64_t * ids_out,
uint64_t ids_out_size,
IkarusErrorData * error_out
) {
IKARUS_FAIL_IF_NULL(project, );
IKARUS_FAIL_IF_NULL(ids_out, );
// TODO, 'InvalidInput' doesn't really make sense here, we'd need to adjust the macros to support distinguishing between different
// errors. In this case `sqlitecpp::MissingRow` and database related errors. Same for the other functions.
IKARUS_VTRYRV_OR_FAIL(
auto const id,
nullptr,
"unable to find entity in database: {}",
IkarusErrorInfo_Client_InvalidInput,
project->db->query_one<int64_t>("SELECT `id` FROM `entities` WHERE `name` = ?", name)
);
if (ids_out == 0) {
return;
}
return project->get_entity(id);
}
struct IkarusProperty *
get_property_by_name(IkarusProject * project, IkarusPropertyScope * scope, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
IKARUS_VTRYRV_OR_FAIL(
auto const id_and_type,
nullptr,
"unable to find property in database: {}",
IkarusErrorInfo_Client_InvalidInput,
project->db->query_one<int64_t, IkarusValueType>(
"SELECT `id`, `type` FROM `properties` WHERE `name` = ? AND `scope` = ?",
name,
scope->get_id()
IKARUS_TRYRV_OR_FAIL(
,
"unable to fetch project blueprints from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_many_buffered<int64_t>(
"SELECT `id` FROM `blueprints`",
ids_out,
ids_out_size
)
);
auto const [id, type] = id_and_type;
return project->get_property(id, type);
}
IkarusBlueprint * get_blueprints_by_name(IkarusProject * project, char const * name, IkarusErrorData * error_out) {
IKARUS_FAIL_IF_NULL(project, nullptr);
IKARUS_FAIL_IF_NULL(name, nullptr);
IKARUS_FAIL_IF_NAME_INVALID(name, nullptr);
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 id,
nullptr,
"unable to find blueprint in database: {}",
IkarusErrorInfo_Client_InvalidInput,
project->db->query_one<int64_t>("SELECT `id` FROM `blueprints` WHERE `name` = ?", name)
auto const ret,
0,
"unable to fetch project blueprint count from database: {}",
IkarusErrorInfo_Database_QueryFailed,
project->db->query_one<int64_t>("SELECT COUNT(`id`) FROM `blueprints`")
);
return project->get_blueprint(id);
return ret;
}

51
src/ikarus/persistence/project.hpp
View file

@ -1,58 +1,19 @@
#pragma once
#include <cstdint>
#include <memory>
#include <string>
#include <boost/filesystem.hpp>
#include <sqlitecpp/connection.hpp>
#include <ikarus/errors.h>
#include <ikarus/values/value_type.h>
#include <ikarus/objects/blueprint.hpp>
#include <ikarus/objects/entity.hpp>
#include <ikarus/objects/property.hpp>
namespace fs = boost::filesystem;
/// \private
struct IkarusProject {
public:
IkarusProject(std::string_view name, std::string_view path, std::unique_ptr<sqlitecpp::Connection> && db);
public:
[[nodiscard]] auto get_blueprint(int64_t id) -> struct IkarusBlueprint *;
auto uncache(struct IkarusBlueprint * blueprint) -> void;
[[nodiscard]] auto get_entity(int64_t id) -> struct IkarusEntity *;
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(int64_t id, IkarusValueType type) -> struct IkarusProperty *;
auto uncache(struct IkarusProperty * property) -> void;
private:
template<typename T>
[[nodiscard]] T * get_cached_object(int64_t id, auto & cache) {
auto const iter = cache.find(id);
if (iter == cache.cend()) {
return cache.emplace(id, std::make_unique<T>(this, id)).first->second.get();
}
return iter->second.get();
}
template<typename T>
void remove_cached_object(T * object, std::unordered_map<int64_t, std::unique_ptr<T>> & cache) {
cache.erase(object->id);
}
public:
std::string name;
std::string_view path;
boost::filesystem::path path;
std::unique_ptr<sqlitecpp::Connection> db;
private:
std::unordered_map<int64_t, std::unique_ptr<struct IkarusBlueprint>> mutable _blueprints;
std::unordered_map<int64_t, std::unique_ptr<struct IkarusProperty>> mutable _properties;
std::unordered_map<int64_t, std::unique_ptr<struct IkarusEntity>> mutable _entities;
};
constexpr std::string_view DB_PROJECT_NAME_KEY = "PROJECT_NAME";

217
src/ikarus/values/data.cpp Normal file
View file

@ -0,0 +1,217 @@
#include "data.hpp"
#include <nlohmann/json.hpp>
#include <cppbase/result.hpp>
#include <cppbase/templates.hpp>
#include <ikarus/values/data.h>
#include <ikarus/values/errors.hpp>
#include <ikarus/values/schema.h>
#include <ikarus/values/shared.hpp>
auto get_primitive_type(IkarusValueDataPrimitive const & primitive)
-> IkarusValuePrimitiveType {
return std::visit(
cppbase::overloaded{
[](IkarusValueDataPrimitiveToggle const &) {
return IkarusValuePrimitiveType_Toggle;
},
[](IkarusValueDataPrimitiveNumber const &) {
return IkarusValuePrimitiveType_Number;
},
[](IkarusValueDataPrimitiveString const &) {
return IkarusValuePrimitiveType_Text;
}
},
primitive
);
}
auto IkarusValueData::from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValueData, IkarusValueDataParseError> {
if (!json.is_object()) {
return cppbase::err(IkarusJsonError{IkarusJsonInvalidTypeError{}});
}
IkarusValueData value{};
VTRY(
auto type,
deserialize_enum<IkarusValueDataType>(
json,
"type",
IkarusValueDataType_Primitive,
IkarusValueDataType_Tuple
)
);
switch (type) {
case IkarusValueDataType_Primitive: {
VTRY(
auto primitive,
deserialize_enum<IkarusValuePrimitiveType>(
json,
"primitive",
IkarusValuePrimitiveType_Toggle,
IkarusValuePrimitiveType_Text
)
);
switch (primitive) {
case IkarusValuePrimitiveType_Toggle: {
VTRY(auto data, deserialize_any<bool>(json, "data"));
value.variant = IkarusValueDataPrimitiveToggle{data};
break;
}
case IkarusValuePrimitiveType_Number: {
VTRY(auto data, deserialize_any<double>(json, "data"));
value.variant = IkarusValueDataPrimitiveNumber{data};
break;
}
case IkarusValuePrimitiveType_Text: {
VTRY(auto data, deserialize_any<std::string>(json, "data"));
value.variant = IkarusValueDataPrimitiveString{data};
break;
}
}
break;
}
case IkarusValueDataType_List: {
std::vector<cppbase::owning_ptr<IkarusValueData>> values_data{};
VTRY(
auto data_json,
deserialize_any<std::vector<nlohmann::json>>(json, "data")
);
values_data.reserve(data_json.size());
for (auto const & data_json : data_json) {
VTRY(auto value_data, IkarusValueData::from_json(data_json));
values_data.emplace_back(
cppbase::make_owning<IkarusValueData>(std::move(value_data))
);
}
value.variant = IkarusValueDataList{values_data};
break;
}
case IkarusValueDataType_Map: {
std::vector<std::pair<
cppbase::owning_ptr<IkarusValueData>,
cppbase::owning_ptr<IkarusValueData>>>
map_data{};
VTRY(
auto map_data_json,
deserialize_any<std::vector<nlohmann::json>>(json, "data")
);
map_data.reserve(map_data_json.size());
for (auto const & pair_json : map_data_json) {
VTRY(auto key_json, get_key(pair_json, "key"));
VTRY(auto value_json, get_key(pair_json, "value"));
VTRY(auto key, IkarusValueData::from_json(*key_json));
VTRY(auto value, IkarusValueData::from_json(*value_json));
map_data.emplace_back(
cppbase::make_owning<IkarusValueData>(key),
cppbase::make_owning<IkarusValueData>(value)
);
}
value.variant = IkarusValueDataMap{map_data};
break;
}
case IkarusValueDataType_Tuple: {
std::vector<cppbase::owning_ptr<IkarusValueData>> values_data{};
VTRY(
auto values_json,
deserialize_any<std::vector<nlohmann::json>>(json, "data")
);
values_data.reserve(values_json.size());
for (auto const & value_json : values_json) {
VTRY(auto value_data, IkarusValueData::from_json(value_json));
values_data.emplace_back(
cppbase::make_owning<IkarusValueData>(value_data)
);
}
value.variant = IkarusValueDataTuple{values_data};
break;
}
}
return cppbase::ok(value);
}
auto IkarusValueData::to_json(
nlohmann::json & json,
IkarusValueData const & value
) -> void {
std::visit(
cppbase::overloaded{
[&](IkarusValueDataPrimitive const & primitive) {
std::visit(
cppbase::overloaded{
[&](IkarusValueDataPrimitiveToggle const & toggle) {
json["type"] = IkarusValueDataType_Primitive;
json["primitive"] = IkarusValuePrimitiveType_Toggle;
json["data"] = toggle.value;
},
[&](IkarusValueDataPrimitiveNumber const & number) {
json["type"] = IkarusValueDataType_Primitive;
json["primitive"] = IkarusValuePrimitiveType_Number;
json["data"] = number.value;
},
[&](IkarusValueDataPrimitiveString const & string) {
json["type"] = IkarusValueDataType_Primitive;
json["primitive"] = IkarusValuePrimitiveType_Text;
json["data"] = string.value;
}
},
primitive
);
},
[&](IkarusValueDataList const & list) {
json["type"] = IkarusValueDataType_List;
json["data"] = list.values |
std::views::transform([](auto const & data) {
nlohmann::json j;
IkarusValueData::to_json(j, *data);
return j;
}) |
std::ranges::to<std::vector<nlohmann::json>>();
},
[&](IkarusValueDataMap const & map) {
json["type"] = IkarusValueDataType_Map;
json["data"] =
map.values | std::views::transform([](auto const & pair) {
nlohmann::json j;
IkarusValueData::to_json(j["key"], *pair.first);
IkarusValueData::to_json(j["value"], *pair.second);
return j;
}) |
std::ranges::to<std::vector<nlohmann::json>>();
},
[&](IkarusValueDataTuple const & tuple) {
json["type"] = IkarusValueDataType_Tuple;
json["data"] = tuple.values |
std::views::transform([](auto const & data) {
nlohmann::json j;
IkarusValueData::to_json(j, *data);
return j;
}) |
std::ranges::to<std::vector<nlohmann::json>>();
}
},
value.variant
);
}

65
src/ikarus/values/data.hpp Normal file
View file

@ -0,0 +1,65 @@
#pragma once
#include <variant>
#include <vector>
#include <nlohmann/json.hpp>
#include <cppbase/pointer.hpp>
#include <cppbase/result.hpp>
#include <ikarus/values/data.h>
#include <ikarus/values/errors.hpp>
#include <ikarus/values/schema.h>
struct IkarusValueData;
struct IkarusValueDataPrimitiveToggle {
bool value;
};
struct IkarusValueDataPrimitiveNumber {
double value;
};
struct IkarusValueDataPrimitiveString {
std::string value;
};
using IkarusValueDataPrimitive = std::variant<
IkarusValueDataPrimitiveToggle,
IkarusValueDataPrimitiveNumber,
IkarusValueDataPrimitiveString>;
struct IkarusValueDataList {
std::vector<cppbase::owning_ptr<IkarusValueData>> values;
};
struct IkarusValueDataMap {
std::vector<std::pair<
cppbase::owning_ptr<IkarusValueData>,
cppbase::owning_ptr<IkarusValueData>>>
values;
};
struct IkarusValueDataTuple {
std::vector<cppbase::owning_ptr<IkarusValueData>> values;
};
struct IkarusValueData {
using IkarusValueDataVariant = std::variant<
IkarusValueDataPrimitive,
IkarusValueDataList,
IkarusValueDataMap,
IkarusValueDataTuple>;
static auto from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValueData, IkarusValueDataParseError>;
static auto to_json(nlohmann::json & json, IkarusValueData const & value)
-> void;
IkarusValueDataVariant variant;
};
auto get_primitive_type(IkarusValueDataPrimitive const & primitive)
-> IkarusValuePrimitiveType;

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

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

1
src/ikarus/values/entity_property_value.hpp
View file

@ -1 +0,0 @@
#pragma once

36
src/ikarus/values/errors.hpp Normal file
View file

@ -0,0 +1,36 @@
#pragma once
#include <variant>
struct IkarusJsonMissingKeyError {};
struct IkarusJsonInvalidTypeError {};
struct IkarusJsonEnumOutOfBoundsError {};
struct IkarusJsonUnknownError {};
using IkarusJsonError = std::variant<
IkarusJsonMissingKeyError,
IkarusJsonInvalidTypeError,
IkarusJsonEnumOutOfBoundsError,
IkarusJsonUnknownError>;
struct IkarusValueSchemaParseError {
IkarusJsonError error;
};
struct IkarusValueDataParseError {
IkarusJsonError error;
};
struct IkarusValueParseErrorDataSchemaMismatch {};
using IkarusValueParseError = std::variant<
IkarusJsonError,
IkarusValueSchemaParseError,
IkarusValueDataParseError,
IkarusValueParseErrorDataSchemaMismatch>;
using IkarusValuesParseError =
std::variant<IkarusJsonMissingKeyError, IkarusValueParseError>;

65
src/ikarus/values/number_value.cpp
View file

@ -1,65 +0,0 @@
#include "ikarus/values/number_value.h"
#include <boost/functional/overloaded_function.hpp>
#include <ikarus/values/number_value.hpp>
#include <ikarus/values/value_base.hpp>
IkarusNumberValue::IkarusNumberValue():
IkarusValueData{this} {}
IkarusNumberValue * ikarus_number_value_data_create() {
return new IkarusNumberValue{};
}
double const * ikarus_number_value_data_get(IkarusNumberValue * value, size_t idx) {
return ikarus_value_data_base_get(value, idx);
}
size_t ikarus_number_value_data_get_size(IkarusNumberValue const * value) {
return ikarus_value_data_base_get_size(value);
}
void ikarus_number_value_data_set(IkarusNumberValue * value, size_t idx, double new_data) {
return ikarus_value_data_base_set(value, idx, new_data);
}
void ikarus_number_value_data_remove(IkarusNumberValue * value, size_t idx) {
return ikarus_value_data_base_remove(value, idx);
}
void ikarus_number_value_data_insert(IkarusNumberValue * value, size_t idx, long double new_data) {
return ikarus_value_data_base_insert(value, idx, new_data);
}
void ikarus_number_value_data_clear(IkarusNumberValue * value) {
return ikarus_value_data_base_clear(value);
}
bool ikarus_number_value_data_is_undefined(IkarusNumberValue const * value) {
return ikarus_value_data_base_is_undefined(value);
}
void ikarus_number_value_data_set_undefined(IkarusNumberValue * value, bool undefined) {
return ikarus_value_data_base_set_undefined(value, undefined);
}
char const * ikarus_number_value_data_to_string(IkarusNumberValue const * value) {
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value; });
}
bool ikarus_number_value_data_is_equal(IkarusNumberValue const * lhs, IkarusNumberValue const * rhs) {
return ikarus_value_data_base_is_equal(lhs, rhs);
}
IkarusNumberValue * ikarus_number_value_data_copy(IkarusNumberValue const * value) {
return ikarus_value_data_base_copy(value);
}
struct IkarusValueData * ikarus_number_value_data_to_value(IkarusNumberValue * value) {
return ikarus_value_data_base_to_value(value);
}
struct IkarusValueData const * ikarus_number_value_data_to_value_data_const(IkarusNumberValue const * value) {
return ikarus_value_data_base_to_value_data_const(value);
}

25
src/ikarus/values/number_value.hpp
View file

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

177
src/ikarus/values/schema.cpp Normal file
View file

@ -0,0 +1,177 @@
#include "schema.hpp"
#include <cppbase/templates.hpp>
#include <ikarus/values/data.hpp>
#include <ikarus/values/schema.h>
#include <ikarus/values/shared.hpp>
auto IkarusValueSchema::from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValueSchema, IkarusValueSchemaParseError> {
if (!json.is_object()) {
return cppbase::err(
IkarusValueSchemaParseError{
IkarusJsonError{IkarusJsonInvalidTypeError{}}
}
);
}
IkarusValueSchema schema{};
VTRY(
auto type,
deserialize_enum<IkarusValueSchemaType>(
json,
"type",
IkarusValueSchemaType_Primitive,
IkarusValueSchemaType_Tuple
)
);
switch (type) {
case IkarusValueSchemaType_Primitive: {
VTRY(
auto primitive,
deserialize_enum<IkarusValuePrimitiveType>(
json,
"primitive",
IkarusValuePrimitiveType_Toggle,
IkarusValuePrimitiveType_Text
)
);
schema.variant = IkarusValueSchemaPrimitive{primitive};
break;
}
case IkarusValueSchemaType_List: {
VTRY(auto sub_schema, IkarusValueSchema::from_json(json["schema"]));
schema.variant = IkarusValueSchemaList{
cppbase::make_owning<IkarusValueSchema>(std::move(sub_schema))
};
break;
}
case IkarusValueSchemaType_Map: {
VTRY(auto key_schema, IkarusValueSchema::from_json(json["key_schema"]));
VTRY(
auto value_schema,
IkarusValueSchema::from_json(json["value_schema"])
);
schema.variant = IkarusValueSchemaMap{
cppbase::make_owning<IkarusValueSchema>(std::move(key_schema)),
cppbase::make_owning<IkarusValueSchema>(std::move(value_schema))
};
break;
}
case IkarusValueSchemaType_Tuple: {
VTRY(
auto sub_schemas_json,
deserialize_any<std::vector<nlohmann::json>>(json, "schemas")
);
std::vector<cppbase::owning_ptr<IkarusValueSchema>> sub_schemas{};
sub_schemas.reserve(sub_schemas_json.size());
for (auto const & sub_schema_json : sub_schemas_json) {
VTRY(auto schema, IkarusValueSchema::from_json(sub_schema_json));
sub_schemas.emplace_back(
cppbase::make_owning<IkarusValueSchema>(std::move(schema))
);
}
schema.variant = IkarusValueSchemaTuple{sub_schemas};
break;
}
}
return cppbase::ok(std::move(schema));
}
auto IkarusValueSchema::to_json(
nlohmann::json & json,
IkarusValueSchema const & schema
) -> void {
std::visit(
cppbase::overloaded{
[&json](IkarusValueSchemaPrimitive const & schema) {
json["type"] = IkarusValueSchemaType_Primitive;
json["primitive"] = schema.type;
},
[&json](IkarusValueSchemaList const & schema) {
json["type"] = IkarusValueSchemaType_List;
IkarusValueSchema::to_json(json["schema"], *schema.sub_schema);
},
[&json](IkarusValueSchemaMap const & schema) {
json["type"] = IkarusValueSchemaType_Map;
IkarusValueSchema::to_json(
json["key_schema"],
*schema.key_schema
);
IkarusValueSchema::to_json(
json["value_schema"],
*schema.value_schema
);
},
[&json](IkarusValueSchemaTuple const & schema) {
json["type"] = IkarusValueSchemaType_Tuple;
std::vector<nlohmann::json> sub_schemas{};
sub_schemas.reserve(schema.sub_schemas.size());
for (auto const & sub_schema : schema.sub_schemas) {
nlohmann::json sub_schema_json{};
IkarusValueSchema::to_json(sub_schema_json, *sub_schema);
sub_schemas.push_back(sub_schema_json);
}
json["schemas"] = sub_schemas;
}
},
schema.variant
);
}
auto IkarusValueSchema::validate(IkarusValueData const & data) const -> bool {
return std::visit(
cppbase::overloaded{
[](IkarusValueSchemaPrimitive const & schema,
IkarusValueDataPrimitive const & data) {
return get_primitive_type(data) == schema.type;
},
[](IkarusValueSchemaList const & schema,
IkarusValueDataList const & data) {
for (auto const & value : data.values) {
if (!schema.sub_schema->validate(*value)) {
return false;
}
}
return true;
},
[](IkarusValueSchemaMap const & schema,
IkarusValueDataMap const & data) {
for (auto const & pair : data.values) {
if (!schema.key_schema->validate(*pair.first) ||
!schema.value_schema->validate(*pair.second)) {
return false;
}
}
return true;
},
[](IkarusValueSchemaTuple const & schema,
IkarusValueDataTuple const & data) {
if (schema.sub_schemas.size() != data.values.size()) {
return false;
}
for (size_t i = 0; i < schema.sub_schemas.size(); ++i) {
if (!schema.sub_schemas[i]->validate(*data.values[i])) {
return false;
}
}
return true;
},
[](auto const &, auto const &) { return false; }
},
variant,
data.variant
);
}

51
src/ikarus/values/schema.hpp Normal file
View file

@ -0,0 +1,51 @@
#pragma once
#include <string>
#include <variant>
#include <vector>
#include <nlohmann/json.hpp>
#include <cppbase/pointer.hpp>
#include <cppbase/result.hpp>
#include <ikarus/values/errors.hpp>
#include <ikarus/values/schema.h>
struct IkarusValue;
struct IkarusValueData;
struct IkarusValueSchema;
struct IkarusValueSchemaPrimitive {
IkarusValuePrimitiveType type;
};
struct IkarusValueSchemaList {
cppbase::owning_ptr<IkarusValueSchema> sub_schema;
};
struct IkarusValueSchemaMap {
cppbase::owning_ptr<IkarusValueSchema> key_schema;
cppbase::owning_ptr<IkarusValueSchema> value_schema;
};
struct IkarusValueSchemaTuple {
std::vector<cppbase::owning_ptr<IkarusValueSchema>> sub_schemas;
};
struct IkarusValueSchema {
using IkarusValueSchemaVariant = std::variant<
IkarusValueSchemaPrimitive,
IkarusValueSchemaList,
IkarusValueSchemaMap,
IkarusValueSchemaTuple>;
static auto from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValueSchema, IkarusValueSchemaParseError>;
static auto to_json(nlohmann::json & json, IkarusValueSchema const & value)
-> void;
auto validate(IkarusValueData const & data) const -> bool;
IkarusValueSchemaVariant variant;
};

65
src/ikarus/values/shared.hpp Normal file
View file

@ -0,0 +1,65 @@
#pragma once
#include "errors.hpp"
#include <nlohmann/json.hpp>
#include <cppbase/result.hpp>
#include <cppbase/templates.hpp>
inline auto get_key(nlohmann::json const & json, std::string_view key)
-> cppbase::
Result<nlohmann::json::const_iterator, IkarusJsonMissingKeyError> {
auto iter = json.find(key);
if (iter == json.end()) {
return cppbase::err(IkarusJsonMissingKeyError{});
}
return cppbase::ok(iter);
}
template<cppbase::Enum E>
auto serialize_enum(nlohmann::json & json, std::string_view key, E value)
-> void {
json[key] = static_cast<std::underlying_type_t<E>>(value);
}
template<cppbase::Enum E>
requires std::is_integral_v<std::underlying_type_t<E>>
auto deserialize_enum(
nlohmann::json const & json,
std::string_view key,
E min,
E max
) -> cppbase::Result<E, IkarusJsonError> {
VTRY(auto iter, get_key(json, key));
if (!iter->is_number_integer()) {
return cppbase::err(IkarusJsonError{});
}
auto value = iter->get<std::underlying_type_t<E>>();
if (value < static_cast<std::underlying_type_t<E>>(min) ||
value > static_cast<std::underlying_type_t<E>>(max)) {
return cppbase::err(IkarusJsonError{});
}
return cppbase::ok(static_cast<E>(value));
}
template<typename T>
auto deserialize_any(nlohmann::json const & json, std::string_view key)
-> cppbase::Result<T, IkarusJsonError> {
VTRY(auto iter, get_key(json, key));
try {
return cppbase::ok(iter->get<T>());
} catch (nlohmann::json::type_error const &) {
return cppbase::err(IkarusJsonInvalidTypeError{});
} catch (nlohmann::json::out_of_range const &) {
return cppbase::err(IkarusJsonEnumOutOfBoundsError{});
} catch (nlohmann::json::exception const &) {
return cppbase::err(IkarusJsonUnknownError{});
}
}

66
src/ikarus/values/text_value.cpp
View file

@ -1,66 +0,0 @@
#include "ikarus/values/text_value.h"
#include <boost/bind/bind.hpp>
#include <boost/functional/overloaded_function.hpp>
#include <ikarus/values/text_value.hpp>
#include <ikarus/values/value_base.hpp>
IkarusTextValue::IkarusTextValue():
IkarusValueData{this} {}
IkarusTextValue * ikarus_text_value_data_create() {
return new IkarusTextValue{};
}
char const * ikarus_text_value_data_get(IkarusTextValue * value, size_t idx) {
return ikarus_value_data_base_get(value, idx)->data();
}
size_t ikarus_text_value_data_get_size(IkarusTextValue const * value) {
return ikarus_value_data_base_get_size(value);
}
void ikarus_text_value_data_set(IkarusTextValue * value, size_t idx, char const * new_data) {
return ikarus_value_data_base_set(value, idx, new_data);
}
void ikarus_text_value_data_remove(IkarusTextValue * value, size_t idx) {
return ikarus_value_data_base_remove(value, idx);
}
void ikarus_text_value_data_insert(IkarusTextValue * value, size_t idx, char const * new_data) {
return ikarus_value_data_base_insert(value, idx, new_data);
}
void ikarus_text_value_data_clear(IkarusTextValue * value) {
return ikarus_value_data_base_clear(value);
}
bool ikarus_text_value_data_is_undefined(IkarusTextValue const * value) {
return ikarus_value_data_base_is_undefined(value);
}
void ikarus_text_value_data_set_undefined(IkarusTextValue * value, bool undefined) {
return ikarus_value_data_base_set_undefined(value, undefined);
}
char const * ikarus_text_value_data_to_string(IkarusTextValue const * value) {
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value; });
}
bool ikarus_text_value_data_is_equal(IkarusTextValue const * lhs, IkarusTextValue const * rhs) {
return ikarus_value_data_base_is_equal(lhs, rhs);
}
IkarusTextValue * ikarus_text_value_data_copy(IkarusTextValue const * value) {
return ikarus_value_data_base_copy(value);
}
struct IkarusValueData * ikarus_text_value_data_to_value(IkarusTextValue * value) {
return ikarus_value_data_base_to_value(value);
}
struct IkarusValueData const * ikarus_text_value_data_to_value_data_const(IkarusTextValue const * value) {
return ikarus_value_data_base_to_value_data_const(value);
}

24
src/ikarus/values/text_value.hpp
View file

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

66
src/ikarus/values/toggle_value.cpp
View file

@ -1,66 +0,0 @@
#include "ikarus/values/toggle_value.h"
#include <boost/functional/overloaded_function.hpp>
#include <boost/range/adaptors.hpp>
#include <ikarus/values/toggle_value.hpp>
#include <ikarus/values/value_base.hpp>
IkarusToggleValue::IkarusToggleValue():
IkarusValueData{this} {}
IkarusToggleValue * ikarus_toggle_value_data_create() {
return new IkarusToggleValue{};
}
bool const * ikarus_toggle_value_data_get(IkarusToggleValue * value, size_t idx) {
return ikarus_value_data_base_get(value, idx);
}
size_t ikarus_toggle_value_data_get_size(IkarusToggleValue const * value) {
return ikarus_value_data_base_get_size(value);
}
void ikarus_toggle_value_data_set(IkarusToggleValue * value, size_t idx, bool new_data) {
return ikarus_value_data_base_set(value, idx, new_data);
}
void ikarus_toggle_value_data_remove(IkarusToggleValue * value, size_t idx) {
return ikarus_value_data_base_remove(value, idx);
}
void ikarus_toggle_value_data_insert(IkarusToggleValue * value, size_t idx, bool new_data) {
return ikarus_value_data_base_insert(value, idx, new_data);
}
void ikarus_toggle_value_data_clear(IkarusToggleValue * value) {
return ikarus_value_data_base_clear(value);
}
bool ikarus_toggle_value_data_is_undefined(IkarusToggleValue const * value) {
return ikarus_value_data_base_is_undefined(value);
}
void ikarus_toggle_value_data_set_undefined(IkarusToggleValue * value, bool undefined) {
return ikarus_value_data_base_set_undefined(value, undefined);
}
char const * ikarus_toggle_value_data_to_string(IkarusToggleValue const * value) {
return ikarus_value_data_base_to_string(value, [](auto const & value) { return value ? "✓" : "✗"; });
}
bool ikarus_toggle_value_data_is_equal(IkarusToggleValue const * lhs, IkarusToggleValue const * rhs) {
return ikarus_value_data_base_is_equal(lhs, rhs);
}
IkarusToggleValue * ikarus_toggle_value_data_copy(IkarusToggleValue const * value) {
return ikarus_value_data_base_copy(value);
}
struct IkarusValueData * ikarus_toggle_value_data_to_value(IkarusToggleValue * value) {
return ikarus_value_data_base_to_value(value);
}
struct IkarusValueData const * ikarus_toggle_value_data_to_value_data_const(IkarusToggleValue const * value) {
return ikarus_value_data_base_to_value_data_const(value);
}

24
src/ikarus/values/toggle_value.hpp
View file

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

168
src/ikarus/values/value.cpp
View file

@ -1,134 +1,58 @@
#include "ikarus/values/value.h"
#include "value.hpp"
#include <string>
#include <ikarus/values/data.h>
#include <ikarus/values/data.hpp>
#include <ikarus/values/schema.h>
#include <ikarus/values/schema.hpp>
#include <ikarus/values/shared.hpp>
#include <ikarus/values/value.h>
#include <boost/container/small_vector.hpp>
#include <boost/json/src.hpp>
// required for header-only inclusion
#include <cppbase/templates.hpp>
#include <ikarus/values/number_value.hpp>
#include <ikarus/values/text_value.hpp>
#include <ikarus/values/toggle_value.hpp>
#include <ikarus/values/value.hpp>
#include <ikarus/values/value_cardinality.h>
#include <ikarus/values/value_type.h>
IkarusValue::IkarusValue(Data data, IkarusValueCardinality cardinality):
data{data},
cardinality{cardinality} {}
cppbase::Result<IkarusValue *, IkarusValue::FromJsonError> IkarusValue::from_json(boost::json::value json) {
if (auto const * obj = json.if_object(); obj == nullptr) {
return cppbase::err(FromJsonError{});
} else {
int64_t const * type;
int64_t const * cardinality;
boost::json::value const * data;
if (auto const * type_value = obj->if_contains(IKARUS_VALUE_JSON_TYPE_KEY); type_value == nullptr) {
return cppbase::err(FromJsonError{});
} else if (type = type_value->if_int64(); type == nullptr) {
return cppbase::err(FromJsonError{});
auto IkarusValue::from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValue, IkarusValueParseError> {
if (!json.is_object()) {
return cppbase::err(IkarusJsonError{IkarusJsonInvalidTypeError{}});
}
if (auto const * cardinality_value = obj->if_contains(IKARUS_VALUE_JSON_CARDINALITY_KEY); cardinality_value == nullptr) {
return cppbase::err(FromJsonError{});
} else if (cardinality = cardinality_value->if_int64(); cardinality == nullptr) {
return cppbase::err(FromJsonError{});
} else if (*cardinality != IkarusValueCardinality_Single && *cardinality != IkarusValueCardinality_Multiple) {
return cppbase::err(FromJsonError{});
IkarusValue value{};
VTRY(value.schema, IkarusValueSchema::from_json(json["schema"]));
VTRY(value.data, IkarusValueData::from_json(json["data"]));
if (!value.schema.validate(value.data)) {
return cppbase::err(IkarusValueParseErrorDataSchemaMismatch{});
}
if (data = obj->if_contains(IKARUS_VALUE_JSON_DATA_KEY); data == nullptr) {
return cppbase::err(FromJsonError{});
}
auto create_value = [data, cardinality]<typename T>() -> cppbase::Result<IkarusValue *, FromJsonError> {
T * ret = nullptr;
ret->cardinality = *cardinality;
if (data->is_null()) {
ret = new T{};
ret->data = boost::variant2::monostate{};
} else {
auto res =
boost::json::try_value_to<boost::container::small_vector<typename T::DataType, IkarusValue::SMALL_VEC_VALUE_SIZE>>(*data
);
if (res.has_error()) {
return cppbase::err(FromJsonError{});
}
ret = new T{};
ret->data = std::move(res.value());
}
return cppbase::ok(ret);
};
switch (*type) {
case IkarusValueType_Toggle: {
return create_value.operator()<IkarusToggleValue>();
}
case IkarusValueType_Number: {
return create_value.operator()<IkarusNumberValue>();
}
case IkarusValueType_Text: {
return create_value.operator()<IkarusTextValue>();
}
default: {
return cppbase::err(FromJsonError{});
}
}
}
return cppbase::ok(std::move(value));
}
boost::json::value IkarusValue::to_json() const {
auto type = std::visit(
cppbase::overloaded{
[]([[maybe_unused]] IkarusToggleValue const * value) { return IkarusValueType_Toggle; },
[]([[maybe_unused]] IkarusNumberValue const * value) { return IkarusValueType_Number; },
[]([[maybe_unused]] IkarusTextValue const * value) { return IkarusValueType_Text; }
},
data
);
auto data_json = std::visit(
[]<typename T>(T const * value) -> boost::json::value {
return std::visit(
cppbase::overloaded{
[]([[maybe_unused]] boost::variant2::monostate const & data) -> boost::json::value { return nullptr; },
[](auto const & data) -> boost::json::value { return boost::json::value_from(data); }
},
value->data
);
},
data
);
return {
{ IKARUS_VALUE_JSON_TYPE_KEY, type},
{IKARUS_VALUE_JSON_CARDINALITY_KEY, cardinality},
{ IKARUS_VALUE_JSON_DATA_KEY, data_json}
};
auto IkarusValue::to_json(nlohmann::json & json, IkarusValue const & value)
-> void {
IkarusValueSchema::to_json(json["schema"], value.schema);
IkarusValueData::to_json(json["data"], value.data);
}
void ikarus_value_visit(
IkarusValue * value,
void (*toggle_visitor)(IkarusToggleValue *, void *),
void (*number_visitor)(IkarusNumberValue *, void *),
void (*text_visitor)(IkarusTextValue *, void *),
void * data
) {
std::visit(
cppbase::overloaded{
[toggle_visitor, data](IkarusToggleValue * toggle_value) { toggle_visitor(toggle_value, data); },
[number_visitor, data](IkarusNumberValue * number_value) { number_visitor(number_value, data); },
[text_visitor, data](IkarusTextValue * text_value) { text_visitor(text_value, data); }
},
value->data
auto IkarusValues::from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValues, IkarusValuesParseError> {
IkarusValues values{};
for (auto const & json_entry : json) {
VTRY(auto name_json, get_key(json_entry, "name"));
if (!name_json->is_string()) {
return cppbase::err(IkarusJsonInvalidTypeError{});
}
VTRY(auto value_json, get_key(json_entry, "value"));
VTRY(auto value, IkarusValue::from_json(*value_json));
values.values.emplace_back(
std::make_pair(
std::move(name_json->get<std::string_view>()),
std::move(value)
)
);
}
return cppbase::ok(std::move(values));
}

102
src/ikarus/values/value.hpp
View file

@ -1,98 +1,28 @@
#pragma once
#include <boost/json.hpp>
#include <nlohmann/json.hpp>
#include <cppbase/result.hpp>
#include <ikarus/errors.hpp>
#include <ikarus/persistence/project.hpp>
#include <ikarus/values/value_cardinality.h>
constexpr auto IKARUS_VALUE_JSON_TYPE_KEY = "type";
constexpr auto IKARUS_VALUE_JSON_CARDINALITY_KEY = "card";
constexpr auto IKARUS_VALUE_JSON_DATA_KEY = "data";
#include <ikarus/values/data.hpp>
#include <ikarus/values/errors.hpp>
#include <ikarus/values/schema.hpp>
struct IkarusValue {
public:
using Data = std::variant<struct IkarusToggleValue *, struct IkarusNumberValue *, struct IkarusTextValue *>;
constexpr static auto SMALL_VEC_VALUE_SIZE = 8;
IkarusValueSchema schema;
IkarusValueData data;
public:
explicit IkarusValue(Data data, IkarusValueCardinality cardinality);
IkarusValue(IkarusValue const &) = default;
IkarusValue(IkarusValue &&) noexcept = default;
IkarusValue & operator=(IkarusValue const &) = default;
IkarusValue & operator=(IkarusValue &&) noexcept = default;
virtual ~IkarusValue() = default;
public:
struct FromJsonError {};
[[nodiscard]] static cppbase::Result<IkarusValue *, FromJsonError> from_json(boost::json::value json);
[[nodiscard]] boost::json::value to_json() const;
public:
Data data;
IkarusValueCardinality cardinality;
static auto from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValue, IkarusValueParseError>;
static auto to_json(nlohmann::json & json, IkarusValue const & value)
-> void;
};
template<>
struct fmt::formatter<IkarusValue::FromJsonError> {
template<typename FormatParseContext>
constexpr static auto parse(FormatParseContext & ctx) {
return ctx.end();
}
struct IkarusValues {
static auto from_json(nlohmann::json const & json)
-> cppbase::Result<IkarusValues, IkarusValuesParseError>;
static auto to_json(nlohmann::json & json, IkarusValues const & values)
-> void;
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");
}
std::vector<std::pair<std::string, IkarusValue>> values;
};
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;
}
#define IKARUS_FAIL_IF_VALUE_MISSING_IMPL(var_name, entity, name, ret) \
IKARUS_VTRYRV_OR_FAIL( \
bool const var_name, \
ret, \
"unable to check whether value exists: {}", \
IkarusErrorInfo_Database_QueryFailed, \
(entity)->project->db->template query_one<bool>( \
"SELECT EXISTS(SELECT 1 FROM `entity_values` WHERE `entity` = ? AND `name` = ?)", \
(entity)->id, \
name \
) \
) \
\
IKARUS_FAIL_IF(!(var_name), ret, "entity value does not exist", IkarusErrorInfo_Client_Misuse);
#define IKARUS_FAIL_IF_VALUE_MISSING(entity, name, ret) IKARUS_FAIL_IF_VALUE_MISSING_IMPL(CPPBASE_UNIQUE_NAME(exists), entity, name, ret);

126
src/ikarus/values/value_base.hpp
View file

@ -1,126 +0,0 @@
#pragma once
#include <ranges>
#include <boost/container/small_vector.hpp>
#include <cppbase/templates.hpp>
template<typename V>
typename V::DataType const * ikarus_value_data_base_get(V * value, size_t idx) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
return &(*data)[idx];
}
return nullptr;
}
template<typename V>
size_t ikarus_value_data_base_get_size(V const * value) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
return data->size();
}
return 0;
}
template<typename V>
void ikarus_value_data_base_set(V * value, size_t idx, typename V::DataType new_data) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
(*data)[idx] = new_data;
}
}
template<typename V>
void ikarus_value_data_base_remove(V * value, size_t idx) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
data->erase(data->begin() + idx);
}
}
template<typename V>
void ikarus_value_data_base_insert(V * value, size_t idx, typename V::DataType new_data) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
data->insert(data->begin() + idx, new_data);
}
}
template<typename V>
void ikarus_value_data_base_clear(V * value) {
if (auto * data = boost::variant2::get_if<boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>>(
&value->data
);
data != nullptr) {
data->clear();
}
}
template<typename V>
bool ikarus_value_data_base_is_undefined(V const * value) {
return boost::variant2::holds_alternative<boost::variant2::monostate>(value->data);
}
template<typename V>
void ikarus_value_data_base_set_undefined(V * value, bool undefined) {
if (undefined) {
value->data = boost::variant2::monostate{};
} else {
value->data = boost::container::small_vector<typename V::DataType, IkarusValueData::SMALL_VEC_VALUE_SIZE>{};
}
}
template<typename V, std::invocable<typename V::DataType> F>
char const * ikarus_value_data_base_to_string(V const * value, F transformer) {
return boost::variant2::visit(
cppbase::overloaded{
[](boost::variant2::monostate const &) -> char const * { return nullptr; },
[&transformer](auto const & data) -> char const * {
auto buffer = fmt::memory_buffer{};
fmt::format_to(
std::back_inserter(buffer),
"{}",
fmt::join(data | std::views::transform(std::forward<F>(transformer)), ", ")
);
return buffer.data();
}
},
value->data
);
}
template<typename V>
bool ikarus_value_data_base_is_equal(V const * lhs, V const * rhs) {
return lhs->data == rhs->data;
}
template<typename V>
V * ikarus_value_data_base_copy(V const * value) {
return new V{*value};
}
template<typename V>
struct IkarusValueData * ikarus_value_data_base_to_value(V * value) {
return static_cast<IkarusValueData *>(value);
}
template<typename V>
struct IkarusValueData const * ikarus_value_data_base_to_value_data_const(V const * value) {
return static_cast<IkarusValueData const *>(value);
}

0
tests/CMakeLists.txt Normal file
View file

5
tools/cmake/toolchains/mac.cmake Normal file
View file

@ -0,0 +1,5 @@
set(CMAKE_SYSTEM_NAME Darwin)
set(CMAKE_SYSTEM_PROCESSOR arm)
set(CMAKE_PREFIX_PATH "$ENV{HOMEBREW_PREFIX}/opt/llvm")
set(ICU_ROOT "$ENV{HOMEBREW_PREFIX}/opt/icu4c")

5
vendor/CMakeLists.txt vendored
View file

@ -1,3 +1,8 @@
# order is important here since sqlitecpp otherwise duplicates cppbase
add_subdirectory(cppbase)
add_subdirectory(sqlitecpp)
add_subdirectory(json)
if (LIBIKARUS_ENABLE_TESTS)
add_subdirectory(catch2)
endif ()

1
vendor/catch2 vendored Submodule

@ -0,0 +1 @@
Subproject commit f5cee49c71e7c0e805695b03e8af533783789762

1
vendor/json vendored Submodule

@ -0,0 +1 @@
Subproject commit 6057b31df7fe0b958d1795defc108d1f26e26441

2
vendor/sqlitecpp vendored

@ -1 +1 @@
Subproject commit 32fa3c1a9beae1a2c49fdd08cc659ea6153da666
Subproject commit 8edc04b73bdee4b487ca59abd68615fa66c7948b