From c1d352270add2f205d038d7e4f69c1b4f35f014d Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Wed, 19 Jun 2024 11:59:04 +0200
Subject: Added operators to MixedPrecision native class

---
 modules/codec/c++/data.hpp   | 80 ++++++++++++++++++++++++++++++++++++++------
 modules/codec/c++/schema.hpp |  3 ++
 2 files changed, 73 insertions(+), 10 deletions(-)

(limited to 'modules/codec/c++')

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 79f5264..8e0e029 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -88,46 +88,58 @@ private:
 
 template<typename T, size_t N>
 class data<schema::Primitive<T,N>, encode::Native, storage::Default> {
+public:
+	using Schema = schema::Primitive<T,N>;
 private:
-	typename native_data_type<schema::Primitive<T,N>>::type value_;
+	typename native_data_type<Schema>::type value_;
 public:
 	data():value_{}{}
 
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
 
-	data(typename native_data_type<schema::Primitive<T,N>>::type value__):
+	data(typename native_data_type<Schema>::type value__):
 		value_{std::move(value__)}{}
 
-	void set(typename native_data_type<schema::Primitive<T,N>>::type val){
+	void set(typename native_data_type<Schema>::type val){
 		value_ = val;
 	}
 
-	typename native_data_type<schema::Primitive<T,N>>::type get() const {return value_;}
+	typename native_data_type<Schema>::type get() const {return value_;}
 
-	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator*(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, storage::Default> operator*(const data<Schema, encode::Native, storage::Default>& rhs)const{
 		return {get() * rhs.get()};
 	}
 	
-	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator/(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, storage::Default> operator/(const data<Schema, encode::Native, storage::Default>& rhs)const{
 		return {get() / rhs.get()};
 	}
 	
-	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator+(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, storage::Default> operator+(const data<Schema, encode::Native, storage::Default>& rhs)const{
 		return {get() + rhs.get()};
 	}
+	
+	data<Schema, encode::Native, storage::Default>& operator+=(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		value_ += rhs.get();
+		return *this;
+	}
+	
+	data<Schema, encode::Native, storage::Default>& operator-=(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		value_ -= rhs.get();
+		return *this;
+	}
 
-	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator-(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, storage::Default> operator-(const data<Schema, encode::Native, storage::Default>& rhs)const{
 		return {get() - rhs.get()};
 	}
 
 	template<typename Enc>
-	bool operator==(const data<schema::Primitive<T,N>, Enc>& rhs)const{
+	bool operator==(const data<Schema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<schema::Primitive<T,N>, Enc>& rhs) const {
+	bool operator<(const data<Schema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 
@@ -162,6 +174,54 @@ public:
 	void set(typename saw::native_data_type<typename Schema::InterfaceSchema>::type val){
 		value_.set(val.template cast_to<typename Schema::StorageSchema>().get());
 	}
+	
+	data<Schema, encode::Native, storage::Default> operator*(const data<Schema, encode::Native, storage::Default>& rhs) const {
+		using CalcType = typename native_data_type<Schema::InterfaceSchema>::type;
+		CalcType left = static_cast<CalcType>(value_.get());
+		CalcType right = static_cast<CalcType>(rhs.get());
+		return {left * right};
+	}
+	
+	data<Schema, encode::Native, storage::Default> operator/(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		using CalcType = typename native_data_type<Schema::InterfaceSchema>::type;
+		CalcType left = static_cast<CalcType>(value_.get());
+		CalcType right = static_cast<CalcType>(rhs.get());
+		return {left / right};
+	}
+	
+	data<Schema, encode::Native, storage::Default> operator+(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		using CalcType = typename native_data_type<Schema::InterfaceSchema>::type;
+		CalcType left = static_cast<CalcType>(value_.get());
+		CalcType right = static_cast<CalcType>(rhs.get());
+		return {left + right};
+	}
+	
+	data<Schema, encode::Native, storage::Default>& operator+=(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		*this = *this + rhs.get();
+		return *this;
+	}
+
+	data<Schema, encode::Native, storage::Default> operator-(const data<Schema, encode::Native, storage::Default>& rhs)const{
+		using CalcType = typename native_data_type<Schema::InterfaceSchema>::type;
+		CalcType left = static_cast<CalcType>(value_.get());
+		CalcType right = static_cast<CalcType>(rhs.get());
+		return {left - right};
+	}
+	
+	data<Schema, encode::Native, storage::Default>& operator-=(const data<Schema, encode::Native, storage::Default>& rhs) const {
+		*this = *this - rhs.get();
+		return *this;
+	}
+
+	template<typename Enc>
+	bool operator==(const data<Schema, Enc>& rhs)const{
+		return get() == rhs.get();
+	}
+
+	template<typename Enc>
+	bool operator<(const data<Schema, Enc>& rhs) const {
+		return get() < rhs.get();
+	}
 };
 
 /**
diff --git a/modules/codec/c++/schema.hpp b/modules/codec/c++/schema.hpp
index 5a2f440..2ef7c77 100644
--- a/modules/codec/c++/schema.hpp
+++ b/modules/codec/c++/schema.hpp
@@ -88,6 +88,9 @@ template <class T, size_t N> struct Primitive {
 					  (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
 				  "Primitive Type is not supported");
 	static constexpr string_literal name = "Primitive";
+	
+	using InterfaceSchema = Primitive<T,N>;
+	using StorageSchema = Primitive<T,N>;
 };
 
 using Int8 = Primitive<SignedInteger, 1>;
-- 
cgit v1.2.3