codec: Adding some convenience access

1 files changed, 55 insertions, 29 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);