codec: Adding some convenience access

2 files changed, 66 insertions, 35 deletions

diff --git a/modules/codec/c++/data.h b/modules/codec/c++/data.h
index eb24841..ba8f424 100644
--- a/modules/codec/c++/data.h
+++ b/modules/codec/c++/data.h
@@ -181,13 +181,13 @@ public:
 template<typename T, size_t Dim>
 class data<schema::Array<T,Dim>, encode::Native> {
 	private:
-		std::array<std::size_t, Dim> dims_;
+		std::array<uint64_t, Dim> dims_;
 		std::vector<data<T, encode::Native>> value_;
 
-		std::size_t get_full_size() const {
-			std::size_t s = 1;
+		uint64_t get_full_size() const {
+			uint64_t s = 1;
 
-			for(std::size_t iter = 0; iter < Dim; ++iter){
+			for(uint64_t iter = 0; iter < Dim; ++iter){
 				assert(dims_.at(iter) > 0);
 				s *= dims_.at(iter);
 			}
@@ -199,7 +199,7 @@ class data<schema::Array<T,Dim>, encode::Native> {
 		SAW_DEFAULT_COPY(data);
 		SAW_DEFAULT_MOVE(data);
 
-		data(const std::array<std::size_t, Dim>& i):
+		data(const std::array<uint64_t, Dim>& i):
 			dims_{i},
 			value_{}
 		{
@@ -252,12 +252,20 @@ class data<schema::Array<T,Dim>, encode::Native> {
 
 		template<std::integral... Dims>
 		data<T, encode::Native>& at(Dims... i){
-			return value_.at(this->get_flat_index({static_cast<std::size_t>(i)...}));
+			return value_.at(this->get_flat_index({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<std::size_t>(i)...}));
+			return value_.at(this->get_flat_index({static_cast<uint64_t>(i)...}));
+		}
+
+		data<T,encode::Native>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
+			return value_.at(this->get_flat_index(i));
+		}
+		
+		const data<T,encode::Native>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
+			return value_.at(this->get_flat_index(i));
 		}
 		
 		std::size_t get_dim_size(std::size_t i) const {
@@ -266,15 +274,23 @@ class data<schema::Array<T,Dim>, encode::Native> {
 
 		size_t size() const { return value_.size();}
 
-private:	
-		std::size_t get_flat_index(const std::array<std::size_t, Dim>& i) const {
-			std::size_t s = 0;
+		data<schema::FixedArray<schema::UInt64, Dim>> get_dims() const {
+			return {dims_};
+		}
+
+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 {
+			uint64_t s = 0;
 
-			std::size_t stride = 1;
+			uint64_t stride = 1;
 
-			for(std::size_t iter = 0; iter < Dim; ++iter){
-				assert(i.at(iter) < dims_.at(iter));
-				s += i.at(iter) * stride;
+			for(uint64_t iter = 0; iter < Dim; ++iter){
+				assert(i.at(iter).get() < dims_.at(iter));
+				s += i.at(iter).get() * stride;
 				stride *= dims_.at(iter);
 			}
 
@@ -282,23 +298,29 @@ private:
 		}
 };
 
-template<typename T, std::size_t... D>
+template<typename T, uint64_t... D>
 class data<schema::FixedArray<T,D...>, encode::Native> {
 private:
 	//using inner_type = std::array<data<T, encode::Native>, multiply_helper<Dims...>::value>;
 	//std::unique_ptr<inner_type> value_;
-	std::vector<data<T, encode::Native>> value_;
+	using ArrayT = std::array<data<T, encode::Native>, ct_multiply<uint64_t, D...>::value>;
+	ArrayT value_;
 	
 public:
-	data(){
-		value_.resize(ct_multiply<std::size_t, D...>::value);
+	data() = default;
+
+	data(const std::array<typename native_data_type<T>::type, ct_multiply<uint64_t, D...>::value>& data) requires (is_primitive<T>::value)
+	{
+		for(uint64_t i = 0; i < ct_multiply<uint64_t, D...>::value; ++i){
+			value_.at(i).set(data.at(i));
+		}
 	}
-	
-	data<T, encode::Native>& at(const std::array<std::size_t, sizeof...(D)>& ind){
+
+	data<T, encode::Native>& at(const std::array<uint64_t, sizeof...(D)>& ind){
 		return value_.at(this->get_flat_index(ind));
 	}
 		
-	const data<T, encode::Native>& at(const std::array<std::size_t, sizeof...(D)>& ind) const {
+	const data<T, encode::Native>& at(const std::array<uint64_t, sizeof...(D)>& ind) const {
 		return value_.at(this->get_flat_index(ind));
 	}
 
@@ -312,19 +334,23 @@ public:
 		return value_.at(this->get_flat_index({i...}));
 	}
 
-	template<std::size_t i>
-	std::size_t get_dim_size() const {
-		return parameter_pack_value<i, std::size_t, D...>::value;
+	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)>> get_dims() const {
+		return {std::array<uint64_t, sizeof...(D)>{D...}};
 	}
 private:
-	std::size_t get_flat_index(const std::array<std::size_t, sizeof...(D)>& i) const {
-		std::size_t s = 0;
+	uint64_t get_flat_index(const std::array<uint64_t, sizeof...(D)>& i) const {
+		uint64_t s = 0;
 
-		std::size_t stride = 1;
+		uint64_t stride = 1;
 
-		constexpr static std::array<std::size_t, sizeof...(D)> dims_{D...};
+		constexpr static std::array<uint64_t, sizeof...(D)> dims_{D...};
 
-		for(std::size_t iter = 0; iter < sizeof...(D); ++iter){
+		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);
diff --git a/modules/codec/tests/codec.cpp b/modules/codec/tests/codec.cpp
index e2a9958..652c55d 100644
--- a/modules/codec/tests/codec.cpp
+++ b/modules/codec/tests/codec.cpp
@@ -81,13 +81,16 @@ SAW_TEST("One dimensional Array Add"){
 SAW_TEST("Two Dimensional Array") {
 	using namespace saw;
 
-	data<schema::TwoDimArray, encode::Native> arr{10,50u};
+	data<schema::TwoDimArray, encode::Native> arr{10,30u};
+
+	int expected_sum = (300 * 301) / 2;
 
 	int bar = 0;
 
 	for(size_t i = 0; i < arr.get_dim_size(0); ++i){
 		for(size_t j = 0; j < arr.get_dim_size(1); ++j){
-			arr.at(i,j).set(bar++);
+			++bar;
+			arr.at(i,j).set(bar);
 		}
 	}
 	int sum = 0;
@@ -96,20 +99,22 @@ SAW_TEST("Two Dimensional Array") {
 			sum += arr.at(i,j).get();
 		}
 	}
-	SAW_EXPECT(sum == 124750, std::to_string(sum) + " is not 124750. Expected that data stays correct");
+	SAW_EXPECT(sum == expected_sum, std::to_string(sum) + " is not "+ std::to_string(expected_sum) + ". Expected that data stays correct");
 }
 
 SAW_TEST("Three Dimensional Array") {
 	using namespace saw;
 
-	data<schema::ThreeDimArray, encode::Native> arr{10,10u,5};
+	data<schema::ThreeDimArray, encode::Native> arr{10,10u,3};
+	int expected_sum = (300 * 301) / 2;
 
 	int bar = 0;
 
 	for(size_t i = 0; i < arr.get_dim_size(0); ++i){
 		for(size_t j = 0; j < arr.get_dim_size(1); ++j){
 			for(size_t k = 0; k < arr.get_dim_size(2); ++k){
-				arr.at(i,j,k).set(bar++);
+				++bar;
+				arr.at(i,j,k).set(bar);
 			}
 		}
 	}
@@ -121,7 +126,7 @@ SAW_TEST("Three Dimensional Array") {
 			}
 		}
 	}
-	SAW_EXPECT(sum == 124750, std::to_string(sum) + " is not 124750. Expected that data stays correct");
+	SAW_EXPECT(sum == expected_sum, std::to_string(sum) + " is not "+ std::to_string(expected_sum) + ". Expected that data stays correct");
 }
 
 SAW_TEST("KelSimple UInt16 write"){