From 6e5178260017e492921090aea95f0120d9f5e66d Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Tue, 9 Apr 2024 14:47:40 +0200
Subject: codec: Fixed some fixedArray issues

---
 modules/codec/c++/data.hpp | 128 +++++++++++++++++++++++++--------------------
 1 file changed, 71 insertions(+), 57 deletions(-)

(limited to 'modules')

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 2cf2a96..5ad4e3f 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -82,6 +82,53 @@ private:
 	static_assert(always_false<T>, "Type not supported");
 };
 
+template<typename T, size_t N>
+class data<schema::Primitive<T,N>, encode::Native> {
+private:
+	typename native_data_type<schema::Primitive<T,N>>::type value_;
+public:
+	data():value_{}{}
+
+	SAW_DEFAULT_COPY(data);
+	SAW_DEFAULT_MOVE(data);
+
+	data(typename native_data_type<schema::Primitive<T,N>>::type value__):
+		value_{std::move(value__)}{}
+
+	void set(typename native_data_type<schema::Primitive<T,N>>::type val){
+		value_ = val;
+	}
+
+	typename native_data_type<schema::Primitive<T,N>>::type get() const {return value_;}
+
+	data<schema::Primitive<T,N>, encode::Native> operator*(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
+		return {get() * rhs.get()};
+	}
+	
+	data<schema::Primitive<T,N>, encode::Native> operator/(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
+		return {get() / rhs.get()};
+	}
+	
+	data<schema::Primitive<T,N>, encode::Native> operator+(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
+		return {get() + rhs.get()};
+	}
+
+	data<schema::Primitive<T,N>, encode::Native> operator-(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
+		return {get() - rhs.get()};
+	}
+
+	template<typename Enc>
+	bool operator==(const data<schema::Primitive<T,N>, Enc>& rhs)const{
+		return get() == rhs.get();
+	}
+
+	template<typename Enc>
+	bool operator<(const data<schema::Primitive<T,N>, Enc>& rhs) const {
+		return get() < rhs.get();
+	}
+};
+
+
 template<typename... T, string_literal... literals>
 class data<schema::Union<schema::Member<T, literals>...>, encode::Native> {
 private:
@@ -182,6 +229,7 @@ public:
 template<typename T, size_t Dim>
 class data<schema::Array<T,Dim>, encode::Native> {
 	private:
+		// data<schema::FixedArray<schema::UInt64, Dim>> dims_;
 		std::array<uint64_t, Dim> dims_;
 		std::vector<data<T, encode::Native>> value_;
 
@@ -250,22 +298,22 @@ class data<schema::Array<T,Dim>, encode::Native> {
 			static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension");
 		}
 
-		data<T, encode::Native>& at(const std::array<std::size_t, Dim>& ind){
+		data<T, encode::Native>& at(const std::array<uint64_t, Dim>& ind){
 			return value_.at(this->get_flat_index(ind));
 		}
 		
-		const data<T, encode::Native>& at(const std::array<std::size_t, Dim>& ind) const {
+		const data<T, encode::Native>& at(const std::array<uint64_t, Dim>& ind) const {
 			return value_.at(this->get_flat_index(ind));
 		}
 
 		template<std::integral... Dims>
 		data<T, encode::Native>& at(Dims... i){
-			return value_.at(this->get_flat_index({static_cast<uint64_t>(i)...}));
+			return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}));
 		}
 		
 		template<std::integral... Dims>
 		const data<T, encode::Native>& at(Dims... i) const {
-			return value_.at(this->get_flat_index({static_cast<uint64_t>(i)...}));
+			return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}));
 		}
 
 		data<T,encode::Native>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
@@ -287,19 +335,31 @@ class data<schema::Array<T,Dim>, encode::Native> {
 		}
 
 private:
-		uint64_t get_flat_index(const std::array<uint64_t, Dim>& i) const {
-			return get_flat_index(data<schema::FixedArray<schema::UInt64,Dim>>{i});
-		}
-
-		uint64_t get_flat_index(const data<schema::FixedArray<schema::UInt64,Dim>>& i) const {
+		template<typename U>
+		uint64_t get_flat_index(const U& i) const {
+			static_assert(
+					std::is_same_v<U,data<schema::FixedArray<schema::UInt64,Dim>>> or
+					std::is_same_v<U,std::array<uint64_t,Dim>>,
+					"Unsupported type"
+			);
 			assert(value_.size() == get_full_size());
 			uint64_t s = 0;
 
 			uint64_t stride = 1;
 
 			for(uint64_t iter = 0; iter < Dim; ++iter){
-				assert(i.at(iter).get() < dims_.at(iter));
-				s += i.at(iter).get() * stride;
+				uint64_t ind = [](auto val) -> uint64_t {
+					using V = std::decay_t<decltype(val)>;
+					if constexpr (std::is_same_v<V,data<schema::UInt64>>){
+						return val.get();
+					}else if constexpr (std::is_same_v<V, uint64_t>){
+						return val;
+					}else{
+						static_assert(always_false<V>, "Cases exhausted");
+					}
+				}(i.at(iter));
+				assert(ind < dims_.at(iter));
+				s += ind * stride;
 				stride *= dims_.at(iter);
 			}
 
@@ -413,51 +473,5 @@ public:
 	}
 };
 
-template<typename T, size_t N>
-class data<schema::Primitive<T,N>, encode::Native> {
-private:
-	typename native_data_type<schema::Primitive<T,N>>::type value_;
-public:
-	data():value_{}{}
-
-	SAW_DEFAULT_COPY(data);
-	SAW_DEFAULT_MOVE(data);
-
-	data(typename native_data_type<schema::Primitive<T,N>>::type value__):
-		value_{std::move(value__)}{}
-
-	void set(typename native_data_type<schema::Primitive<T,N>>::type val){
-		value_ = val;
-	}
-
-	typename native_data_type<schema::Primitive<T,N>>::type get() const {return value_;}
-
-	data<schema::Primitive<T,N>, encode::Native> operator*(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
-		return {get() * rhs.get()};
-	}
-	
-	data<schema::Primitive<T,N>, encode::Native> operator/(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
-		return {get() / rhs.get()};
-	}
-	
-	data<schema::Primitive<T,N>, encode::Native> operator+(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
-		return {get() + rhs.get()};
-	}
-
-	data<schema::Primitive<T,N>, encode::Native> operator-(const data<schema::Primitive<T,N>, encode::Native>& rhs)const{
-		return {get() - rhs.get()};
-	}
-
-	template<typename Enc>
-	bool operator==(const data<schema::Primitive<T,N>, Enc>& rhs)const{
-		return get() == rhs.get();
-	}
-
-	template<typename Enc>
-	bool operator<(const data<schema::Primitive<T,N>, Enc>& rhs) const {
-		return get() < rhs.get();
-	}
-};
-
 
 }
-- 
cgit v1.2.3