From 4a4bfa2ccf179e15a5b8e98f398c16f693ddd3e5 Mon Sep 17 00:00:00 2001
From: Claudius 'keldu' Holeksa <mail@keldu.de>
Date: Sat, 7 Sep 2024 19:25:12 +0200
Subject: Fixing raw data encoding. Prep for C layer

---
 modules/codec/c++/data_raw.hpp    | 190 +++++++++++++++++++++++++++++++-------
 modules/codec/c++/schema_meta.hpp |   6 ++
 modules/codec/tests/data_raw.cpp  |  26 ++++++
 3 files changed, 191 insertions(+), 31 deletions(-)

diff --git a/modules/codec/c++/data_raw.hpp b/modules/codec/c++/data_raw.hpp
index 88a0ee2..37e56d9 100644
--- a/modules/codec/c++/data_raw.hpp
+++ b/modules/codec/c++/data_raw.hpp
@@ -123,6 +123,77 @@ public:
 	}
 };
 
+template<typename T, uint64_t N>
+class data<schema::Ref<schema::Primitive<T,N>>, encode::NativeRaw> {
+public:
+	using ReferencedSchema = schema::Primitive<T,N>;
+	using Schema = schema::Ref<ReferencedSchema>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
+private:
+	ref<typename native_data_type<ReferencedSchema>::type > value_;
+public:
+	data(ref<typename native_data_type<ReferencedSchema >::type > value__):
+		value_{value__}
+	{}
+
+	SAW_DEFAULT_COPY(data);
+	SAW_FORBID_MOVE(data);
+
+	void set(typename native_data_type<ReferencedSchema>::type val){
+		value_() = val;
+	}
+
+	typename native_data_type<ReferencedSchema>::type get() const {
+		return value_();
+	}
+	
+	data<ReferencedSchema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs)const{
+		return {get() * rhs.get()};
+	}
+	
+	data<ReferencedSchema, encode::NativeRaw> operator/(const data<Schema, encode::NativeRaw>& rhs)const{
+		return {get() / rhs.get()};
+	}
+	
+	data<ReferencedSchema, encode::NativeRaw> operator+(const data<Schema, encode::NativeRaw>& rhs)const{
+		return {get() + rhs.get()};
+	}
+	
+	data<Schema, encode::NativeRaw>& operator+=(const data<Schema, encode::NativeRaw>& rhs)const{
+		value_ += rhs.get();
+		return *this;
+	}
+	
+	data<Schema, encode::NativeRaw>& operator-=(const data<Schema, encode::NativeRaw>& rhs)const{
+		value_ -= rhs.get();
+		return *this;
+	}
+
+	data<ReferencedSchema, encode::NativeRaw> operator-(const data<Schema, encode::NativeRaw>& rhs)const{
+		return {get() - rhs.get()};
+	}
+
+	template<typename Enc>
+	bool operator==(const data<Schema, Enc>& rhs)const{
+		return get() == rhs.get();
+	}
+	
+	template<typename Enc>
+	bool operator==(const data<ReferencedSchema, Enc>& rhs)const{
+		return get() == rhs.get();
+	}
+
+	template<typename Enc>
+	bool operator<(const data<Schema, Enc>& rhs) const {
+		return get() < rhs.get();
+	}
+	
+	template<typename Enc>
+	bool operator<(const data<ReferencedSchema, Enc>& rhs) const {
+		return get() < rhs.get();
+	}
+};
+
 /**
  * Mixed precision class for native formats
  */
@@ -223,7 +294,7 @@ private:
 	
 	template<uint64_t i = 0u>
 	struct init_helper {
-		static void apply(std::tuple<data<T,encode::NativeRaw,storage::Default>...>& val, data<Schema, encode::NativeRaw>&& init){
+		static void apply(std::tuple<data<T,encode::NativeRaw>...>& val, data<Schema, encode::NativeRaw>&& init){
 			auto& val_i = val.template get<i>();
 			auto& init_i = init.template get<i>();
 
@@ -294,7 +365,7 @@ private:
 
 	template<uint64_t i = 0u>
 	struct init_helper {
-		static void apply(std::tuple<data<T,encode::NativeRaw,storage::Default>...>& val, data<MetaSchema, encode::NativeRaw>&& init){
+		static void apply(std::tuple<data<T,encode::NativeRaw>...>& val, data<MetaSchema, encode::NativeRaw>&& init){
 			auto& val_i = val.template get<i>();
 			auto& init_i = init.template get<i>();
 
@@ -337,20 +408,10 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 		using Schema = schema::Array<T,Dim>;
 		using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 
-		using DataType = std::conditional<
-			is_primitive<typename T>::value,
-			typename native_data_type<typename T::StorageSchema>::type
-		>;
 	private:
 		// data<schema::FixedArray<schema::UInt64, Dim>> dims_;
 		std::array<uint64_t, Dim> dims_;
-		std::vector<
-			std::conditional<
-				is_primitive<Schema>::value,
-				typename native_data_type<T>::type,
-				data<T, encode::NativeRaw>
-			>
-		> value_;
+		std::vector<typename raw_native_array_type_helper<T>::Type> value_;
 
 		uint64_t get_full_size() const {
 			uint64_t s = 1;
@@ -425,30 +486,32 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 			static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension");
 		}
 
-		data<T, encode::NativeRaw>& at(const std::array<uint64_t, Dim>& ind){
-			return value_.at(this->get_flat_index(ind));
+		data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind){
+			return {value_.at(this->get_flat_index(ind))};
 		}
 		
-		const data<T, encode::NativeRaw>& at(const std::array<uint64_t, Dim>& ind) const {
-			return value_.at(this->get_flat_index(ind));
+		const data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind) const {
+			return {value_.at(this->get_flat_index(ind))};
 		}
 
 		template<std::integral... Dims>
-		data<T, encode::NativeRaw>& at(Dims... i){
-			return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}));
+		data<schema::Ref<T>, encode::NativeRaw> at(Dims... 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::NativeRaw>& at(Dims... i) const {
-			return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}));
+		const data<schema::Ref<T>, encode::NativeRaw> at(Dims... i) const {
+			return {value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}))};
 		}
 
-		data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
-			return value_.at(this->get_flat_index(i));
+		template<typename Encoding>
+		data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i){
+			return {value_.at(this->get_flat_index(i))};
 		}
 		
-		const data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
-			return value_.at(this->get_flat_index(i));
+		template<typename Encoding>
+		const data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i)const{
+			return {value_.at(this->get_flat_index(i))};
 		}
 		
 		std::size_t get_dim_size(uint64_t i) const {
@@ -457,18 +520,13 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 
 		size_t size() const { return value_.size();}
 
-		data<schema::FixedArray<schema::UInt64, Dim>> get_dims() const {
+		data<schema::FixedArray<schema::UInt64, Dim>, encode::NativeRaw> get_dims() const {
 			return {dims_};
 		}
 
 private:
 		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;
 
@@ -494,5 +552,75 @@ private:
 		}
 };
 
+template<typename T, uint64_t... D>
+class data<schema::FixedArray<T,D...>, encode::NativeRaw> {
+public:
+	using Schema = schema::FixedArray<T,D...>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
+private:
+	//using inner_type = std::array<data<T, encode::Native>, multiply_helper<Dims...>::value>;
+	//std::unique_ptr<inner_type> value_;
+	using ArrayT = std::array<typename raw_native_array_type_helper<T>::Type, ct_multiply<uint64_t, D...>::value>;
+	ArrayT value_;
+	
+public:
+	data() = default;
+	data(data<MetaSchema, encode::NativeRaw>){}
+	data(const std::array<data<T, encode::NativeRaw>, ct_multiply<uint64_t,D...>::value>& value__):
+		value_{value__}
+	{}
+
+	data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, sizeof...(D)>& ind){
+		return {value_.at(this->get_flat_index(ind))};
+	}
+		
+	const data<schema::Ref<T>, encode::Native> at(const std::array<uint64_t, sizeof...(D)>& ind) const {
+		return {value_.at(this->get_flat_index(ind))};
+	}
+
+	template<std::integral... Dims>
+	data<schema::Ref<T>, encode::Native> at(Dims... i) {
+		return {value_.at(this->get_flat_index({i...}))};
+	}
+
+	template<std::integral... Dims>
+	const data<schema::Ref<T>, encode::Native> at(Dims... i) const {
+		return {value_.at(this->get_flat_index({i...}))};
+	}
+
+	data<schema::Ref<T>, encode::Native> at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw>& i){
+		return {value_.at(this->get_flat_index(i))};
+	}
+	
+	const data<schema::Ref<T>, encode::Native> at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw>& i)const{
+		return {value_.at(this->get_flat_index(i))};
+	}
+
+	template<uint64_t i>
+	uint64_t get_dim_size() const {
+		return parameter_pack_value<i, uint64_t, D...>::value;
+	}
+
+	data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw> get_dims() const {
+		return {std::array<uint64_t, sizeof...(D)>{D...}};
+	}
+private:
+	uint64_t get_flat_index(const std::array<uint64_t, sizeof...(D)>& i) const {
+		uint64_t s = 0;
+
+		uint64_t stride = 1;
+
+		constexpr static std::array<uint64_t, sizeof...(D)> dims_{D...};
+
+		for(uint64_t iter = 0; iter < sizeof...(D); ++iter){
+			assert(i.at(iter) < dims_.at(iter));
+			s += i.at(iter) * stride;
+			stride *= dims_.at(iter);
+		}
+
+		return s;
+	}
+};
+
 
 }
diff --git a/modules/codec/c++/schema_meta.hpp b/modules/codec/c++/schema_meta.hpp
index 9b111e3..80b6686 100644
--- a/modules/codec/c++/schema_meta.hpp
+++ b/modules/codec/c++/schema_meta.hpp
@@ -33,6 +33,12 @@ struct meta_schema<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Prim
 	using MetaSchema = schema::Void;
 };
 
+template<typename T>
+struct meta_schema<schema::Ref<T>> {
+	using MetaSchema = schema::Void;
+	using Schema = schema::Ref<T>;
+};
+
 template<typename Key, typename Value>
 struct meta_schema<schema::Map<Key,Value>> {
 	using MetaSchema = schema::Void;
diff --git a/modules/codec/tests/data_raw.cpp b/modules/codec/tests/data_raw.cpp
index 99d55a8..11e2c5e 100644
--- a/modules/codec/tests/data_raw.cpp
+++ b/modules/codec/tests/data_raw.cpp
@@ -4,7 +4,33 @@
 namespace {
 namespace sch {
 using namespace saw::schema;
+
+using Int32Array = Array<
+	Int32
+>;
 }
 
+SAW_TEST("Data NativeRaw/Array of Primitives"){
+	using namespace saw;
+
+	data<sch::Int32Array,encode::NativeRaw> prim{4u};
+	prim.at(1u).set(0);
+
+	auto a = prim.at(1u);
+
+	a.set(5);
+
+	auto b = prim.at(1u);
+	// Check if it's a reference being manipulated
+	SAW_EXPECT(a.get() == 5, "'a' has unexpected value.");
+	SAW_EXPECT(b.get() == 5, "'b' has unexpected value.");
+	
+	auto c = prim.at(1u);
+	c.set(10);
+
+	SAW_EXPECT(a.get() == 10, "'a' has unexpected value.");
+	SAW_EXPECT(b.get() == 10, "'b' has unexpected value.");
+	SAW_EXPECT(c.get() == 10, "'c' has unexpected value.");
+}
 
 }
-- 
cgit v1.2.3