From 7d094fe719923db5eb6b30edcc4fa01c6ce2cc2e Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Fri, 7 Aug 2026 12:34:22 +0200
Subject: Cleaning up code

---
 modules/core/c++/abstract/data.hpp  | 89 +++++++++++++++++++++++++++++++++++++
 modules/core/c++/abstract/error.hpp |  2 +-
 2 files changed, 90 insertions(+), 1 deletion(-)

(limited to 'modules/core/c++/abstract')

diff --git a/modules/core/c++/abstract/data.hpp b/modules/core/c++/abstract/data.hpp
index f1ae5a7..327fb63 100644
--- a/modules/core/c++/abstract/data.hpp
+++ b/modules/core/c++/abstract/data.hpp
@@ -10,8 +10,97 @@ class data final {};
 
 template<typename T, uint64_t N>
 class data<sch::Primitive<T,N>,Encode> final {
+public:
+	using Schema = sch::Primitive<T,N>;
+	using Encode = Encode;
 private:
+	native_data_type<Schema>::type value_;
 public:
+	data():
+		value_{}
+	{}
+
+	data(native_data_type<Schema>::type value__):
+		value_{value__}
+	{}
+
+	constexpr auto get() const {
+		return value_;
+	}
+
+	void set(native_data_type value__){
+		value_ = value__;
+	}
+
+	constexpr bool operator==(const data<Schema,Encode>& rhs) const {
+		return value_ == rhs.value_;
+	}
+	
+	constexpr bool operator!=(const data<Schema,Encode>& rhs) const {
+		return value_ != rhs.value_;
+	}
+	
+	constexpr bool operator>(const data<Schema,Encode>& rhs) const {
+		return value_ > rhs.value_;
+	}
+	
+	constexpr bool operator<(const data<Schema,Encode>& rhs) const {
+		return value_ < rhs.value_;
+	}
+	
+	constexpr bool operator>=(const data<Schema,Encode>& rhs) const {
+		return value_ >= rhs.value_;
+	}
+	
+	constexpr bool operator<=(const data<Schema,Encode>& rhs) const {
+		return value_ >= rhs.value_;
+	}
+	
+	constexpr bool equals(const data<Schema,Encode>& rhs) const {
+		return (*this) == rhs;
+	}
+
+	data<Schema,Encode> operator+(const data<Schema,Encode>& rhs) const {
+		return {value_ + rhs.value_};
+	}
+	
+	data<Schema,Encode> operator-(const data<Schema,Encode>& rhs) const {
+		return {value_ - rhs.value_};
+	}
+	
+	data<Schema,Encode> operator*(const data<Schema,Encode>& rhs) const {
+		return {value_ * rhs.value_};
+	}
+	
+	data<Schema,Encode> operator/(const data<Schema,Encode>& rhs) const {
+		return {value_ / rhs.value_};
+	}
+	
+	data<Schema,Encode>& operator+=(const data<Schema,Encode>& rhs) {
+		value_ += rhs.value_;
+		return *this
+	}
+	
+	data<Schema,Encode>& operator-=(const data<Schema,Encode>& rhs) {
+		value_ -= rhs.value_;
+		return *this
+	}
+	
+	data<Schema,Encode>& operator*=(const data<Schema,Encode>& rhs) {
+		value_ *= rhs.value_;
+		return *this
+	}
+	
+	data<Schema,Encode>& operator/=(const data<Schema,Encode>& rhs) {
+		value_ /= rhs.value_;
+		return *this
+	}
+
+	template<typename T>
+	data<T,Encode> cast_to() const {
+		data<T,Encode> val{static_cast<typename native_data_type<T>::type>(value_)};
+		return val;
+	}
 };
 
 
diff --git a/modules/core/c++/abstract/error.hpp b/modules/core/c++/abstract/error.hpp
index 19917de..94a2c35 100644
--- a/modules/core/c++/abstract/error.hpp
+++ b/modules/core/c++/abstract/error.hpp
@@ -305,7 +305,7 @@ public:
 
 /**
  * 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.
+ * So this acts as a type safe guard in case internal handling fails to treat conversion correctly.
  */
 template <typename T> class error_or<error_or<T>> {
 private:
-- 
cgit v1.2.3