summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--modules/core/c++/abstract/common.hpp154
-rw-r--r--modules/core/c++/abstract/error.hpp324
2 files changed, 478 insertions, 0 deletions
diff --git a/modules/core/c++/abstract/common.hpp b/modules/core/c++/abstract/common.hpp
new file mode 100644
index 0000000..408946c
--- /dev/null
+++ b/modules/core/c++/abstract/common.hpp
@@ -0,0 +1,154 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <utility>
+
+namespace saw {
+
+#define KEL_CONCAT_(x, y) x##y
+#define KEL_CONCAT(x, y) KEL_CONCAT_(x, y)
+#define KEL_UNIQUE_NAME(prefix) KEL_CONCAT(prefix, __LINE__)
+
+#define KEL_FORBID_COPY(classname) \
+ classname(const classname &) = delete; \
+ classname &operator=(const classname &) = delete
+
+#define KEL_FORBID_MOVE(classname) \
+ classname(classname &&) = delete; \
+ classname &operator=(classname &&) = delete
+
+#define KEL_DEFAULT_COPY(classname) \
+ classname(const classname &) = default; \
+ classname &operator=(const classname &) = default
+
+#define KEL_DEFAULT_MOVE(classname) \
+ classname(classname &&) = default; \
+ classname &operator=(classname &&) = default
+
+// In case of C++20
+#define KEL_ASSERT(expression) \
+ assert(expression); \
+ if (!(expression)) [[unlikely]]
+
+template <typename T> using maybe = std::optional<T>;
+
+template <typename T> using own = std::unique_ptr<T>;
+
+template <typename T> using our = std::shared_ptr<T>;
+
+template <typename T> using lent = std::weak_ptr<T>;
+
+template<typename T>
+class ptr {
+private:
+ T* ptr_;
+
+public:
+ ptr():
+ ptr_{nullptr}
+ {}
+
+ ptr(T& ptr__):
+ ptr_{&ptr__}
+ {}
+
+ KEL_DEFAULT_COPY(ptr);
+ KEL_DEFAULT_MOVE(ptr);
+
+ T& operator()(){
+ return *ptr_;
+ }
+
+ const T& operator()() const {
+ return *ptr_;
+ }
+
+ bool is_valid() const {
+ return ptr_ != nullptr;
+ }
+};
+
+/**
+ * Reference class for easier distinction
+ * of references and its referenced types.
+ */
+template <typename T>
+class ref {
+private:
+ /**
+ * Referenced type
+ */
+ T* ref_;
+
+ /**
+ * We don't want to move since the would invalidate the type.
+ */
+ KEL_FORBID_MOVE(ref);
+public:
+ /**
+ * Main constructor.
+ */
+ constexpr ref(T& ref__):
+ ref_{&ref__}
+ {}
+
+ KEL_DEFAULT_COPY(ref);
+
+ /**
+ * Operator retrieving the itself.
+ */
+ constexpr T& operator()(){
+ return *ref_;
+ }
+
+ /**
+ * Operator retrieving the itself.
+ */
+ constexpr const T& operator()() const {
+ return *ref_;
+ }
+};
+
+template <typename T, class... Args> own<T> heap(Args &&...args) {
+ return own<T>(new T(std::forward<Args>(args)...));
+}
+
+template <typename T, class... Args> our<T> share(Args &&...args) {
+ return std::make_shared<T>(std::forward<Args>(args)...);
+}
+
+template <typename T> T instance() noexcept;
+
+template <typename Func, typename T> struct return_type_helper {
+ typedef decltype(instance<Func>()(instance<T>())) Type;
+};
+template <typename Func> struct return_type_helper<Func, void> {
+ typedef decltype(instance<Func>()()) Type;
+};
+
+template <typename Func, typename T>
+using return_type = typename return_type_helper<Func, T>::Type;
+
+/**
+ * Struct describing a void type
+ */
+struct void_t {};
+
+/**
+ * Helper function since changing returns between void_t{} and make_error<...>() is a bit annoying.
+ */
+void_t make_void();
+
+template <typename T> struct void_fix { typedef T Type; };
+template <> struct void_fix<void> { typedef void_t Type; };
+template <typename T> using fix_void = typename void_fix<T>::Type;
+
+template <typename T> struct void_unfix { typedef T Type; };
+template <> struct void_unfix<void_t> { typedef void Type; };
+template <typename T> using unfix_void = typename void_unfix<T>::Type;
+
+template <typename... T> constexpr bool always_false = false;
+
+} // namespace saw
diff --git a/modules/core/c++/abstract/error.hpp b/modules/core/c++/abstract/error.hpp
new file mode 100644
index 0000000..19917de
--- /dev/null
+++ b/modules/core/c++/abstract/error.hpp
@@ -0,0 +1,324 @@
+#pragma once
+
+#include <algorithm>
+#include <limits>
+#include <functional>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+#include <cassert>
+
+#include "common.hpp"
+
+namespace saw {
+/**
+ * Utility class for generating errors. Has a base distinction between
+ * critical and recoverable errors. Additional code ids can be provided to the
+ * constructor if additional distinctions are necessary.
+ */
+class error final {
+public:
+ /**
+ * Type alias
+ */
+ using code = uint32_t;
+private:
+ /**
+ * Type representing the error code used to distinguish the different error types
+ */
+ code error_code_;
+ /**
+ * Helper variable for ease of checking if it's a critical error.
+ */
+ bool is_critical_;
+ /**
+ * Member holding the message. It's a variant for edge cases where we are out of memory.
+ */
+ std::variant<std::string_view, std::string> error_message_;
+
+public:
+ error(error::code id, bool is_critical);
+ error(error::code id, bool is_critical, const std::string_view &msg);
+ error(error::code id, bool is_critical, std::string&& msg);
+ error(error &&error);
+
+ KEL_FORBID_COPY(error);
+
+ error &operator=(error &&) = default;
+
+ /**
+ * Returns a string view to the message
+ */
+ const std::string_view get_message() const;
+
+ /**
+ * Returns a string view which describes which error this is.
+ */
+ const std::string_view get_category() const;
+
+ /**
+ * Checks if it's an error at all, since 0 is reserved for no error.
+ */
+ bool failed() const;
+
+ /**
+ * Checks if the error is critical.
+ */
+ bool is_critical() const;
+
+ /**
+ * Checks if the error is recoverable.
+ */
+ bool is_recoverable() const;
+
+ /**
+ * Replaces the copy constructor. We need this since we want to explicitly copy and not implicitly
+ */
+ error copy_error() const;
+
+ /**
+ * Return the id.
+ */
+ code get_id() const;
+
+ /**
+ * Provide an error struct and check if it matches the type
+ */
+ template<typename T>
+ bool is_type() const;
+};
+
+/**
+ * Class which is basically a variant. Replaces exceptions
+ */
+template<typename T>
+class error_or;
+
+namespace impl {
+
+/**
+ * Internal registry for all error types. Is generated dynamically.
+ */
+class error_registry final {
+private:
+ struct error_info {
+ error_info() = delete;
+ error_info(const std::string_view& d_, bool critical_):description{d_}, is_critical{critical_}{}
+
+ std::string_view description;
+ bool is_critical;
+ };
+
+ std::vector<error_info> infos_;
+public:
+ error_registry();
+
+ KEL_FORBID_COPY(error_registry);
+ KEL_FORBID_MOVE(error_registry);
+
+ error_or<const std::string_view> search_category(const error::code& id) const;
+
+ error_or<error::code> search_id(const std::string_view& desc) const;
+
+ error_or<error::code> search_or_register_id(const std::string_view& desc, bool is_critical);
+
+ bool is_critical(error::code cd) const;
+};
+
+error_registry& get_error_registry();
+
+template<typename T>
+error::code get_template_error_id(){
+ static error::code id = std::numeric_limits<error::code>::max();
+
+ if(id == std::numeric_limits<error::code>::max()){
+ auto& reg = get_error_registry();
+
+ auto err_or_id = reg.search_or_register_id(T::description, T::is_critical);
+ if(err_or_id.is_error()){
+ return std::numeric_limits<error::code>::max();
+ }
+
+ id = err_or_id.get_value();
+ }
+
+ return id;
+}
+}
+
+error make_error(error::code code, const std::string_view &generic);
+
+template<typename T> error make_error(const std::string_view& generic){
+ error::code id = impl::get_template_error_id<T>();
+ // Keep error, don't use make_error
+ return error{id, T::is_critical, generic};
+}
+
+template<typename T> error make_error(){
+ error::code id = impl::get_template_error_id<T>();
+ // Keep error, don't use make_error
+ return error{id, T::is_critical};
+}
+
+struct error_builder {
+private:
+ std::function<std::string()> func_;
+public:
+ template<typename Func>
+ error_builder(Func&& func__):
+ func_{std::move(func__)}
+ {}
+
+ template<typename T>
+ error make_error(const std::string_view& generic){
+ try{
+ std::string err_str = func_();
+ error::code id = impl::get_template_error_id<T>();
+ func_ = [](){return "";};
+ return error{id, T::is_critical, std::move(err_str)};
+ }catch(const std::exception&){}
+ return make_error<T>(generic);
+ }
+};
+
+template<typename Func>
+error_builder build_error(Func&& func){
+ return error_builder{std::move(func)};
+}
+
+namespace err {
+struct no_error {
+ static constexpr std::string_view description = "No error has occured";
+ static constexpr bool is_critical = false;
+};
+
+struct recoverable {
+ static constexpr std::string_view description = "Generic recoverable error";
+ static constexpr bool is_critical = false;
+};
+
+struct critical {
+ static constexpr std::string_view description = "Generic critical error";
+ static constexpr bool is_critical = true;
+};
+
+struct buffer_exhausted {
+ static constexpr std::string_view description = "Buffer Exhausted";
+ static constexpr bool is_critical = false;
+};
+
+struct not_found {
+ static constexpr std::string_view description = "Not found";
+ static constexpr bool is_critical = false;
+};
+
+struct out_of_memory {
+ static constexpr std::string_view description = "Out of memory";
+ static constexpr bool is_critical = true;
+};
+
+struct invalid_state {
+ static constexpr std::string_view description = "Invalid state";
+ static constexpr bool is_critical = true;
+};
+
+struct not_supported {
+ static constexpr std::string_view description = "Not supported";
+ static constexpr bool is_critical = false;
+};
+
+struct not_implemented {
+ static constexpr std::string_view description = "Not implemented";
+ static constexpr bool is_critical = true;
+};
+
+struct already_exists {
+ static constexpr std::string_view description = "Already exists";
+ static constexpr bool is_critical = false;
+};
+}
+
+/**
+ * Shorthand for no error happened
+ */
+error no_error();
+
+/**
+ * Exception alternative. Since I code without exceptions this class is
+ * essentially a kind of exception replacement.
+ */
+template <typename T> class error_or;
+
+class error_or_value {
+public:
+ virtual ~error_or_value() = default;
+
+ template <typename T> error_or<unfix_void<T>> &as() {
+ return static_cast<error_or<unfix_void<T>> &>(*this);
+ }
+
+ template <typename T> const error_or<unfix_void<T>> &as() const {
+ return static_cast<const error_or<unfix_void<T>> &>(*this);
+ }
+};
+
+template <typename T> class error_or final : public error_or_value {
+private:
+ std::variant<error, fix_void<T>> value_or_error_;
+
+ static_assert(!std::is_same_v<T, void_t>,
+ "Don't use internal private types");
+
+public:
+ constexpr error_or():value_or_error_{make_error<err::invalid_state>("Default assignement for error_or constructor.")}{}
+ constexpr error_or(const fix_void<T> &value) : value_or_error_{value} {}
+
+ constexpr error_or(fix_void<T> &&value) : value_or_error_{std::move(value)} {}
+
+ constexpr error_or(const error &error) : value_or_error_{error} {}
+ constexpr error_or(error &&error) : value_or_error_{std::move(error)} {}
+
+ constexpr bool is_value() const {
+ return std::holds_alternative<fix_void<T>>(value_or_error_);
+ }
+
+ constexpr bool is_error() const {
+ return std::holds_alternative<class error>(value_or_error_);
+ }
+
+ constexpr class error &get_error() {
+ return std::get<class error>(value_or_error_);
+ }
+
+ constexpr const class error &get_error() const {
+ return std::get<class error>(value_or_error_);
+ }
+
+ constexpr fix_void<T> &get_value() { return std::get<fix_void<T>>(value_or_error_); }
+
+ constexpr const fix_void<T> &get_value() const {
+ return std::get<fix_void<T>>(value_or_error_);
+ }
+};
+
+/**
+ * This tries to catch cases where error starts including itself as a type which can happen in more complicated cases.
+ * So this acts as a type safe guard.
+ */
+template <typename T> class error_or<error_or<T>> {
+private:
+ error_or() = delete;
+};
+
+template<typename T>
+bool error::is_type() const {
+
+ return error_code_ == impl::get_template_error_id<T>();
+}
+
+} // namespace saw
+
+#define KEL_MAKE_ERROR(ErrType, ErrMsg) \
+ return saw::make_error<ErrType>(ErrMsg)
generated by cgit v1.2.3 (git 2.25.1) at 2026-07-21 18:38:10 +0000