From 25e05907f0292310eaae27a032db0ee274413874 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Tue, 2 Jul 2024 19:46:02 +0200
Subject: Preparing benchmark work

---
 modules/codec/c++/data.hpp     | 47 ++++++++++++++++++++++++------------------
 modules/codec/c++/rpc.hpp      |  5 +++--
 modules/codec/c++/transfer.hpp |  8 +++----
 3 files changed, 34 insertions(+), 26 deletions(-)

(limited to 'modules/codec')

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 5ebe579..dd70cd9 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -86,8 +86,8 @@ private:
 	static_assert(always_false<T>, "Type not supported");
 };
 
-template<typename T, size_t N>
-class data<schema::Primitive<T,N>, encode::Native, storage::Default> {
+template<typename T, size_t N, typename Storage>
+class data<schema::Primitive<T,N>, encode::Native, Storage> {
 public:
 	using Schema = schema::Primitive<T,N>;
 private:
@@ -107,29 +107,29 @@ public:
 
 	typename native_data_type<Schema>::type get() const {return value_;}
 
-	data<Schema, encode::Native, storage::Default> operator*(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage> operator*(const data<Schema, encode::Native, Storage>& rhs)const{
 		return {get() * rhs.get()};
 	}
 	
-	data<Schema, encode::Native, storage::Default> operator/(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage> operator/(const data<Schema, encode::Native, Storage>& rhs)const{
 		return {get() / rhs.get()};
 	}
 	
-	data<Schema, encode::Native, storage::Default> operator+(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage> operator+(const data<Schema, encode::Native, Storage>& rhs)const{
 		return {get() + rhs.get()};
 	}
 	
-	data<Schema, encode::Native, storage::Default>& operator+=(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage>& operator+=(const data<Schema, encode::Native, Storage>& rhs)const{
 		value_ += rhs.get();
 		return *this;
 	}
 	
-	data<Schema, encode::Native, storage::Default>& operator-=(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage>& operator-=(const data<Schema, encode::Native, Storage>& rhs)const{
 		value_ -= rhs.get();
 		return *this;
 	}
 
-	data<Schema, encode::Native, storage::Default> operator-(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage> operator-(const data<Schema, encode::Native, Storage>& rhs)const{
 		return {get() - rhs.get()};
 	}
 
@@ -147,7 +147,7 @@ public:
 	 * Casts 
 	 */
 	template<typename Target>
-	data<Target, encode::Native, storage::Default> cast_to(){
+	data<Target, encode::Native, Storage> cast_to(){
 		auto raw_to = static_cast<typename saw::native_data_type<Target>::type>(value_);
 		return {raw_to};
 	}
@@ -156,12 +156,12 @@ public:
 /**
  * Mixed precision class for native formats
  */
-template<typename TA, uint64_t NA, typename TB, uint64_t NB> 
-class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native, storage::Default>{
+template<typename TA, uint64_t NA, typename TB, uint64_t NB, typename Storage> 
+class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native, Storage>{
 public:
 	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
 private:
-	data<typename Schema::StorageSchema, encode::Native, storage::Default> value_;
+	data<typename Schema::StorageSchema, encode::Native, Storage> value_;
 public:
 	data():value_{}{}
 
@@ -175,51 +175,58 @@ public:
 		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 {
+	data<Schema, encode::Native, Storage> operator*(const data<Schema, encode::Native, Storage>& rhs) const {
 		using CalcType = typename native_data_type<typename 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{
+	data<Schema, encode::Native, Storage> operator*(const data<typename Schema::InterfaceSchema, encode::Native, Storage>& rhs) const {
+		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
+		CalcType left = static_cast<CalcType>(value_.get());
+		CalcType right = rhs.get();
+		return {left * right};
+	}
+	
+	data<Schema, encode::Native, Storage> operator/(const data<Schema, encode::Native, Storage>& rhs)const{
 		using CalcType = typename native_data_type<typename 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{
+	data<Schema, encode::Native, Storage> operator+(const data<Schema, encode::Native, Storage>& rhs)const{
 		using CalcType = typename native_data_type<typename 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{
+	data<Schema, encode::Native, Storage>& operator+=(const data<Schema, encode::Native, Storage>& rhs)const{
 		*this = *this + rhs.get();
 		return *this;
 	}
 
-	data<Schema, encode::Native, storage::Default> operator-(const data<Schema, encode::Native, storage::Default>& rhs)const{
+	data<Schema, encode::Native, Storage> operator-(const data<Schema, encode::Native, Storage>& rhs)const{
 		using CalcType = typename native_data_type<typename 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 {
+	data<Schema, encode::Native, Storage>& operator-=(const data<Schema, encode::Native, Storage>& rhs) const {
 		*this = *this - rhs.get();
 		return *this;
 	}
 
 	template<typename Enc>
-	bool operator==(const data<Schema, Enc>& rhs)const{
+	bool operator==(const data<Schema, Enc, Storage>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<Schema, Enc>& rhs) const {
+	bool operator<(const data<Schema, Enc, Storage>& rhs) const {
 		return get() < rhs.get();
 	}
 };
diff --git a/modules/codec/c++/rpc.hpp b/modules/codec/c++/rpc.hpp
index 2c97d6b..d172ec4 100644
--- a/modules/codec/c++/rpc.hpp
+++ b/modules/codec/c++/rpc.hpp
@@ -9,7 +9,6 @@
 #include <variant>
 
 namespace saw {
-
 /**
  * This class acts as a helper for rpc calls and representing data on the remote.
  */
@@ -139,7 +138,9 @@ template<typename Remote>
 class remote_address {
 	static_assert(always_false<Remote>, "Type of remote not supported");
 
-
+	/**
+	 *
+	 */
 };
 
 /**
diff --git a/modules/codec/c++/transfer.hpp b/modules/codec/c++/transfer.hpp
index b6aa977..1fb297e 100644
--- a/modules/codec/c++/transfer.hpp
+++ b/modules/codec/c++/transfer.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
 namespace saw {
-template<typename T>
-class data_client;
-
-template<typename T>
+template<typename Schema, typename Encoding, typename Remote>
 class data_server;
+
+template<typename Schema, typename Encoding, typename Remote>
+class data_client;
 }
-- 
cgit v1.2.3