From 44b97c0c13c3cb05a5fed70326285b45bc7b37a6 Mon Sep 17 00:00:00 2001
From: Claudius Holeksa <mail@keldu.de>
Date: Mon, 26 Jun 2023 15:25:29 +0200
Subject: c++,codec: Added kelsimple array and struct decoding / encoding

---
 src/codec/simple.h | 166 +++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 161 insertions(+), 5 deletions(-)

(limited to 'src/codec/simple.h')

diff --git a/src/codec/simple.h b/src/codec/simple.h
index 1b6cf0d..ad66f66 100644
--- a/src/codec/simple.h
+++ b/src/codec/simple.h
@@ -1,6 +1,12 @@
 #pragma once
 
 #include "data.h"
+#include "stream_value.h"
+
+#include <iostream>
+
+#include <forstio/core/buffer.h>
+#include <forstio/core/error.h>
 
 namespace saw {
 namespace encode {
@@ -15,7 +21,7 @@ public:
 	data() = default;
 
 	buffer& get_buffer(){
-		return buffer;
+		return buffer_;
 	}
 };
 
@@ -25,13 +31,152 @@ class kelsimple_encode {
 	static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding.");
 };
 
-template<typename T, size_t N, typename Schema, typename FromEnc>
+template<typename T, size_t N, typename FromEnc>
 struct kelsimple_encode<schema::Primitive<T,N>, FromEnc> {
 	static error_or<void> encode(const data<schema::Primitive<T,N>, FromEnc>& from, buffer& to){
-		
+		auto eov = stream_value<schema::Primitive<T,N>>::encode(from.get(), to);
+		return eov;
+	}
+};
+
+template<typename T, size_t Dim, typename FromEnc>
+struct kelsimple_encode<schema::Array<T,Dim>, FromEnc> {
+	template<std::size_t Level>
+	static error_or<void> encode_level(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to, std::array<std::size_t, Dim>& index){
+		if constexpr (Dim == Level){
+			return kelsimple_encode<T,FromEnc>::encode(from.at(index), to);
+		} else {
+			const std::size_t dim_size = from.get_dim_size(Level);
+			for(index[Level] = 0; (index.at(Level) < dim_size); ++index[Level]){
+				auto eov = encode_level<Level+1>(from, to, index);
+				if(eov.is_error()){
+					return eov;
+				}
+			}
+		}
+		return void_t{};
+	}
+
+	static error_or<void> encode(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to){
+		{
+			for(uint64_t i = 0; i < Dim; ++i){
+				auto eov = stream_value<schema::UInt64>::encode(from.get_dim_size(i), to);
+				if(eov.is_error()){
+					return eov;
+				}
+			}
+		}
+		{
+			std::array<std::size_t, Dim> index;
+			std::fill(index.begin(), index.end(), 0);
+
+			return encode_level<0>(from, to, index);
+		}
+		return void_t{};
+	}
+};
+
+template<typename... T, string_literal... Lits, typename FromEnc>
+struct kelsimple_encode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> {
+	template<std::size_t i>
+	static error_or<void> encode_member(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
+		using Type = typename parameter_pack_type<i,T...>::type;
+		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
+		{
+			auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<Literal>(), to);
+		}
+		if constexpr ((i+1) < sizeof...(T)){
+			auto eov = encode_member<i+1>(from, to);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		return void_t{};
+	}
+
+	static error_or<void> encode(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){
+		return encode_member<0>(from, to);
+	}
+};
+
+template<typename Schema, typename FromEnc>
+class kelsimple_decode {
+	static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding.");
+};
+
+template<typename T, size_t N, typename FromEnc>
+struct kelsimple_decode<schema::Primitive<T,N>, FromEnc> {
+	static error_or<void> decode(buffer& from, data<schema::Primitive<T,N>, FromEnc>& to){
+		typename native_data_type<schema::Primitive<T,N>>::type val{};
+		auto eov = stream_value<schema::Primitive<T,N>>::decode(val, from);
+		if (eov.is_value()) {
+			to.set(val);
+		}
+		return eov;
+	}
+
+};
 
+template<typename T, size_t Dim, typename FromEnc>
+struct kelsimple_decode<schema::Array<T,Dim>, FromEnc> {
+	template<std::size_t Level>
+	static error_or<void> decode_level(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to, std::array<std::size_t, Dim>& index){
+		if constexpr (Level == Dim){
+			return kelsimple_decode<T, FromEnc>::decode(from, to.at(index));
+		}else{
+			const std::size_t dim_size = to.get_dim_size(Level);
+			for(index[Level] = 0; index[Level] < dim_size; ++index[Level]){
+				auto eov = decode_level<Level+1>(from, to, index);
+				if(eov.is_error()){
+					return eov;
+				}
+			}
+		}
+		return void_t{};
+	}
+
+	static error_or<void> decode(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to){
+		{
+			std::array<std::size_t, Dim> dims{};
+			for(std::size_t i = 0; i < Dim; ++i){
+				uint64_t val{};
+				auto eov = stream_value<schema::UInt64>::decode(val, from);
+				if(eov.is_error()){
+					return eov;
+				}
+				dims.at(i) = static_cast<std::size_t>(val);
+			}
+			to = data<schema::Array<T,Dim>,FromEnc>{dims};
+		}
+		{
+			std::array<std::size_t, Dim> index{};
+			return decode_level<0>(from, to, index);
+		}
+		return void_t{};
+	}
+};
+template<typename... T, string_literal... Lits, typename FromEnc>
+struct kelsimple_decode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> {
+	template<std::size_t i>
+	static error_or<void> decode_member(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){
+		using Type = typename parameter_pack_type<i,T...>::type;
+		constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
+		{
+			auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<Literal>());
+		}
+		if constexpr ((i+1) < sizeof...(T)){
+			auto eov = decode_member<i+1>(from, to);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
 		return void_t{};
+
 	}
+	static error_or<void> decode(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){
+		return decode_member<0>(from, to);
+	}
+	
 };
 }
 
@@ -54,9 +199,20 @@ public:
 	error_or<void> encode(const data<Schema, FromEnc>& from_enc, data<Schema, encode::KelSimple>& to_enc){
 		buffer_view buff_v{to_enc.get_buffer()};
 
-		auto eov = kelsimple_encode::encode(from_env, buff_v);
+		auto eov = impl::kelsimple_encode<Schema, FromEnc>::encode(from_enc, buff_v);
 
-		return void_t{};
+		to_enc.get_buffer().write_advance(buff_v.write_offset());
+
+		return eov;
+	}
+
+	template<typename ToDec>
+	error_or<void> decode(data<Schema, encode::KelSimple>& from_dec, data<Schema, ToDec>& to){
+		buffer_view buff_v{from_dec.get_buffer()};
+
+		auto eov = impl::kelsimple_decode<Schema,ToDec>::decode(buff_v, to);
+
+		return eov;
 	}
 };
 }
-- 
cgit v1.2.3