From d1d40903a582099762db04feeec451d7f0a617a8 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Tue, 13 Feb 2024 16:26:01 +0100
Subject: codec-json: Removed RootSchema from decoders and encoders

---
 modules/codec-json/c++/json.hpp      |  10 +--
 modules/codec-json/c++/json.tmpl.hpp | 126 ++++++++++++++++++++---------------
 2 files changed, 79 insertions(+), 57 deletions(-)

(limited to 'modules/codec-json')

diff --git a/modules/codec-json/c++/json.hpp b/modules/codec-json/c++/json.hpp
index c7e4203..ad29acb 100644
--- a/modules/codec-json/c++/json.hpp
+++ b/modules/codec-json/c++/json.hpp
@@ -8,7 +8,8 @@
 
 namespace saw {
 namespace encode {
-struct Json {};
+struct Json {
+};
 }
 
 template<typename Schema>
@@ -72,7 +73,8 @@ class codec<Schema, encode::Json> {
 public:
 	struct config {
 		size_t depth = 16;
-		size_t length = 1024;
+		size_t length = 4096;
+		bool pretty = false;
 	};
 private:
 	config cfg_;
@@ -94,7 +96,7 @@ public:
 	error_or<void> encode(const data<Schema, FromEncoding>& from_encode, data<Schema, encode::Json>& to_encode){
 		// To Be encoded
 		buffer_view buff_v{to_encode.get_buffer()};
-		auto eov = impl::json_encode<Schema, Schema, FromEncoding>::encode(from_encode, buff_v);
+		auto eov = impl::json_encode<Schema, FromEncoding>::encode(from_encode, buff_v);
 		if(eov.is_error()){
 			return std::move(eov.get_error());
 		}
@@ -107,7 +109,7 @@ public:
 	error_or<void> decode(data<Schema, encode::Json>& from_decode, data<Schema, ToEncoding>& to_decode){
 		buffer_view buff_v{from_decode.get_buffer()};
 
-		auto eov = impl::json_decode<Schema, Schema, ToEncoding>::decode(buff_v, to_decode);
+		auto eov = impl::json_decode<Schema, ToEncoding>::decode(buff_v, to_decode);
 		if(eov.is_error()){
 			return std::move(eov.get_error());
 		}
diff --git a/modules/codec-json/c++/json.tmpl.hpp b/modules/codec-json/c++/json.tmpl.hpp
index aa8f9b9..11eba49 100644
--- a/modules/codec-json/c++/json.tmpl.hpp
+++ b/modules/codec-json/c++/json.tmpl.hpp
@@ -7,14 +7,16 @@
 
 namespace saw {
 namespace impl {
-template<typename Schema, typename RootSchema, typename FromEncode>
+template<typename Schema, typename FromEncode>
 class json_encode {
-	static_assert(always_false<Schema, RootSchema, FromEncode>, "This schema type is not being handled by the json encoding.");
+	static_assert(always_false<Schema, FromEncode>, "This schema type is not being handled by the json encoding.");
 };
 
-template<typename T, size_t N, typename RootSchema, typename FromEncode>
-struct json_encode<schema::Primitive<T,N>, RootSchema, FromEncode> {
-	static error_or<void> encode(const data<schema::Primitive<T,N>, FromEncode>& from, buffer& to) {
+template<typename T, size_t N, typename FromEncode>
+struct json_encode<schema::Primitive<T,N>, FromEncode> {
+	using Schema = schema::Primitive<T,N>;
+
+	static error_or<void> encode(const data<Schema, FromEncode>& from, buffer& to) {
 		auto val = from.get();
 		std::array<uint8_t, 256> data;
 		auto tc_result = std::to_chars(reinterpret_cast<char*>(data.data()), reinterpret_cast<char*>(data.data())+data.size(), val);
@@ -43,8 +45,10 @@ struct json_encode<schema::Primitive<T,N>, RootSchema, FromEncode> {
 	}
 };
 
-template<typename RootSchema, typename FromEncode>
-struct json_encode<schema::String, RootSchema, FromEncode>  {
+template<typename FromEncode>
+struct json_encode<schema::String, FromEncode>  {
+	using Schema = schema::String;
+
 	static error_or<void> encode(const data<schema::String, FromEncode>& from, buffer& to) {
 		{
 			auto err = to.push('"');
@@ -69,11 +73,13 @@ struct json_encode<schema::String, RootSchema, FromEncode>  {
 	}
 };
 
-template<typename... T, typename RootSchema, typename FromEncode>
-struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {
+template<typename... T, typename FromEncode>
+struct json_encode<schema::Tuple<T...>, FromEncode>  {
+	using Schema = schema::Tuple<T...>;
+
 	template<size_t i>
 	static error_or<void> encode_element(const data<schema::Tuple<T...>, FromEncode>& from, buffer& to){
-		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<i>(), to);
+		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, FromEncode>::encode(from.template get<i>(), to);
 
 		if(eov.is_error()){
 			return eov;
@@ -98,7 +104,7 @@ struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {
 		return void_t{};
 	}
 
-	static error_or<void> encode(const data<schema::Tuple<T...>, FromEncode>& from, buffer& to) {
+	static error_or<void> encode(const data<Schema, FromEncode>& from, buffer& to) {
 		{
 			auto err = to.push('[');
 			if(!err.template is_type<err::no_error>()){
@@ -122,12 +128,14 @@ struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {
 	}
 };
 
-template<typename T, size_t D, typename RootSchema, typename FromEncode>
-struct json_encode<schema::Array<T,D>, RootSchema, FromEncode>  {
+template<typename T, size_t D, typename FromEncode>
+struct json_encode<schema::Array<T,D>, FromEncode>  {
+	using Schema = schema::Array<T,D>;
+
 	template<size_t Level>
-	static error_or<void> encode_level(const data<schema::Array<T,D>, FromEncode>& from, buffer& to, std::array<std::size_t, D>& index){
+	static error_or<void> encode_level(const data<Schema, FromEncode>& from, buffer& to, std::array<std::size_t, D>& index){
 		if constexpr (Level == D){
-			auto eov = json_encode<T, RootSchema, FromEncode>::encode(from.at(index), to);
+			auto eov = json_encode<T, FromEncode>::encode(from.at(index), to);
 			if(eov.is_error()){
 				return eov;
 			}
@@ -163,18 +171,18 @@ struct json_encode<schema::Array<T,D>, RootSchema, FromEncode>  {
 		return void_t{};
 	}
 
-	static error_or<void> encode(const data<schema::Array<T,D>, FromEncode>& from, buffer& to) {
+	static error_or<void> encode(const data<Schema, FromEncode>& from, buffer& to) {
 		std::array<std::size_t, D> index;
 		return encode_level<0>(from, to, index);
 	}
 };
 
-template<typename T, size_t... D, typename RootSchema, typename FromEncode>
-struct json_encode<schema::FixedArray<T,D...>, RootSchema, FromEncode>  {
+template<typename T, size_t... D, typename FromEncode>
+struct json_encode<schema::FixedArray<T,D...>, FromEncode>  {
 	using Schema = schema::FixedArray<T,D...>;
 
 	static error_or<void> encode_at(const data<Schema, FromEncode>& from, buffer& to, std::array<std::size_t, sizeof...(D)>& index){
-		auto eov = json_encode<T, RootSchema, FromEncode>::encode(from.at(index), to);
+		auto eov = json_encode<T, FromEncode>::encode(from.at(index), to);
 		if(eov.is_error()){
 			return eov;
 		}
@@ -229,11 +237,12 @@ struct json_encode<schema::FixedArray<T,D...>, RootSchema, FromEncode>  {
 	}
 };
 
-template<typename... T, string_literal... Key, typename RootSchema, typename FromEncode>
-struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEncode>  {
+template<typename... T, string_literal... Key, typename FromEncode>
+struct json_encode<schema::Struct<schema::Member<T,Key>...>, FromEncode>  {
+	using Schema = schema::Struct<schema::Member<T,Key>...>;
 
 	template<size_t i>
-	static error_or<void> encode_element(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to){
+	static error_or<void> encode_element(const data<Schema, FromEncode>& from, buffer& to){
 		// Encode the name
 		{
 			std::string_view view = parameter_key_pack_type<i, Key...>::literal.view();
@@ -259,7 +268,7 @@ struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEnc
 		}
 	
 		// Encode the value
-		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
+		auto eov = json_encode<typename parameter_pack_type<i, T...>::type, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
 		
 		// Go to the next element
 		if constexpr ( (i+1) < sizeof...(T)){
@@ -281,7 +290,7 @@ struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEnc
 
 		return void_t{};
 	}
-	static error_or<void> encode(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to) {
+	static error_or<void> encode(const data<Schema, FromEncode>& from, buffer& to) {
 		{
 			auto err = to.push('{');
 			if(!err.template is_type<err::no_error>()){
@@ -305,11 +314,12 @@ struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEnc
 	}
 };
 
-template<typename... T, string_literal... Key, typename RootSchema, typename FromEncode>
-struct json_encode<schema::Union<schema::Member<T,Key>...>, RootSchema, FromEncode>  {
+template<typename... T, string_literal... Key, typename FromEncode>
+struct json_encode<schema::Union<schema::Member<T,Key>...>, FromEncode>  {
+	using Schema = schema::Union<schema::Member<T,Key>...>;
 
 	template<size_t i>
-	static error_or<void> encode_element(const data<schema::Union<schema::Member<T,Key>...>, FromEncode>& from, buffer& to){
+	static error_or<void> encode_element(const data<Schema, FromEncode>& from, buffer& to){
 		if(from.template holds_alternative<parameter_key_pack_type<i, Key...>::literal>()){
 			// Encode the name
 			{
@@ -336,7 +346,7 @@ struct json_encode<schema::Union<schema::Member<T,Key>...>, RootSchema, FromEnco
 			}
 		
 			// Encode the value
-			auto eov = json_encode<typename parameter_pack_type<i, T...>::type, RootSchema, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
+			auto eov = json_encode<typename parameter_pack_type<i, T...>::type, FromEncode>::encode(from.template get<parameter_key_pack_type<i, Key...>::literal>(), to);
 		}
 		// Go to the next element
 		if constexpr ( (i+1) < sizeof...(T)){
@@ -352,7 +362,7 @@ struct json_encode<schema::Union<schema::Member<T,Key>...>, RootSchema, FromEnco
 
 		return void_t{};
 	}
-	static error_or<void> encode(const data<schema::Union<schema::Member<T,Key>...>, FromEncode>& from, buffer& to) {
+	static error_or<void> encode(const data<Schema, FromEncode>& from, buffer& to) {
 		{
 			auto err = to.push('{');
 			if(!err.template is_type<err::no_error>()){
@@ -388,12 +398,14 @@ struct json_helper {
 	}
 };
 
-template<typename Schema, typename RootSchema, typename ToDecode>
+template<typename Schema, typename ToDecode>
 struct json_decode;
 
-template<typename T, size_t N, typename RootSchema, typename ToDecode>
-struct json_decode<schema::Primitive<T,N>, RootSchema, ToDecode> {
-	static error_or<void> decode(buffer_view& buff, data<schema::Primitive<T,N>, ToDecode>& to) {
+template<typename T, size_t N, typename ToDecode>
+struct json_decode<schema::Primitive<T,N>, ToDecode> {
+	using Schema = schema::Primitive<T,N>;
+
+	static error_or<void> decode(buffer_view& buff, data<Schema, ToDecode>& to) {
 		assert(
 		   ( buff.read() >= '0' && buff.read() <= '9')
 		   || ( buff.read() == '+' || buff.read() == '-')
@@ -435,7 +447,7 @@ struct json_decode<schema::Primitive<T,N>, RootSchema, ToDecode> {
 
 		{
 			std::string_view num_view{reinterpret_cast<char*>(&buff.read()), offset};
-			typename native_data_type<schema::Primitive<T,N>>::type result;
+			typename native_data_type<Schema>::type result;
 			auto fc_result = std::from_chars(num_view.data(), num_view.data() + num_view.size(), result);
 			if(fc_result.ec != std::errc{}){
 				return make_error<err::invalid_state>();
@@ -449,9 +461,11 @@ struct json_decode<schema::Primitive<T,N>, RootSchema, ToDecode> {
 	}	
 };
 
-template<typename RootSchema, typename ToDecode>
-struct json_decode<schema::String, RootSchema, ToDecode> {
-	static error_or<void> decode(buffer_view& buff, data<schema::String, ToDecode>& to){
+template<typename ToDecode>
+struct json_decode<schema::String, ToDecode> {
+	using Schema = schema::String;
+
+	static error_or<void> decode(buffer_view& buff, data<Schema, ToDecode>& to){
 		assert(buff.read() == '"');
 		buff.read_advance(1);
 
@@ -534,10 +548,12 @@ struct json_decode<schema::String, RootSchema, ToDecode> {
 	}
 };
 
-template<typename... T, string_literal... Lits, typename RootSchema, typename ToDecode>
-struct json_decode<schema::Struct<schema::Member<T,Lits>...>, RootSchema, ToDecode> {
+template<typename... T, string_literal... Lits, typename ToDecode>
+struct json_decode<schema::Struct<schema::Member<T,Lits>...>, ToDecode> {
+	using Schema = schema::Struct<schema::Member<T,Lits>...>;
+
 	template<std::size_t i>
-	static error_or<void> decode_field_search(buffer_view& buff, data<schema::Struct<schema::Member<T,Lits>...>, ToDecode>& to, std::array<bool, sizeof...(T)>& fields, const data<schema::String,ToDecode>& search_name){
+	static error_or<void> decode_field_search(buffer_view& buff, data<Schema, ToDecode>& to, std::array<bool, sizeof...(T)>& fields, const data<schema::String,ToDecode>& search_name){
 		if constexpr ( i < sizeof...(T)){
 			using Type = typename parameter_pack_type<i, T...>::type;
 			constexpr static string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
@@ -546,7 +562,7 @@ struct json_decode<schema::Struct<schema::Member<T,Lits>...>, RootSchema, ToDeco
 					return make_error<err::invalid_state>();
 				}
 				fields[i] = true;
-				auto eov = json_decode<Type, RootSchema, ToDecode>::decode(buff, to.template get<Literal>());
+				auto eov = json_decode<Type, ToDecode>::decode(buff, to.template get<Literal>());
 				if(eov.is_error()){
 					return eov;
 				}
@@ -559,10 +575,10 @@ struct json_decode<schema::Struct<schema::Member<T,Lits>...>, RootSchema, ToDeco
 		return void_t{};
 	}
 
-	static error_or<void> decode_fields(buffer_view& buff, data<schema::Struct<schema::Member<T,Lits>...>, ToDecode>& to, std::array<bool, sizeof...(T)>& fields){
+	static error_or<void> decode_fields(buffer_view& buff, data<Schema, ToDecode>& to, std::array<bool, sizeof...(T)>& fields){
 		for(;;){
 			data<schema::String, ToDecode> name;
-			auto eov = json_decode<schema::String, RootSchema, ToDecode>::decode(buff, name);
+			auto eov = json_decode<schema::String, ToDecode>::decode(buff, name);
 			if(eov.is_error()){
 				return eov;
 			}
@@ -610,7 +626,7 @@ struct json_decode<schema::Struct<schema::Member<T,Lits>...>, RootSchema, ToDeco
 		return void_t{};
 	}
 
-	static error_or<void> decode(buffer_view& buff, data<schema::Struct<schema::Member<T,Lits>...>, ToDecode>& to){
+	static error_or<void> decode(buffer_view& buff, data<Schema, ToDecode>& to){
 		std::array<bool, sizeof...(T)> found_fields;
 		std::fill(found_fields.begin(), found_fields.end(), false);
 
@@ -639,10 +655,12 @@ struct json_decode<schema::Struct<schema::Member<T,Lits>...>, RootSchema, ToDeco
 	}
 };
 
-template<typename... T, typename RootSchema, typename ToDecode>
-struct json_decode<schema::Tuple<T...>, RootSchema, ToDecode> {
+template<typename... T, typename ToDecode>
+struct json_decode<schema::Tuple<T...>, ToDecode> {
+	using Schema = schema::Tuple<T...>;
+
 	template<std::size_t i>
-	static error_or<void> decode_element(buffer_view& buff, data<schema::Tuple<T...>, ToDecode>& to){
+	static error_or<void> decode_element(buffer_view& buff, data<Schema, ToDecode>& to){
 		if constexpr (i < sizeof...(T)){
 			if constexpr ( i > 0 ){
 				if(buff.read() != ','){
@@ -655,7 +673,7 @@ struct json_decode<schema::Tuple<T...>, RootSchema, ToDecode> {
 			}
 			using Type = typename parameter_pack_type<i, T...>::type;
 
-			auto eov = json_decode<Type, RootSchema, ToDecode>::decode(buff, to.template get<i>());
+			auto eov = json_decode<Type, ToDecode>::decode(buff, to.template get<i>());
 			if(eov.is_error()){
 				return eov;
 			}
@@ -677,7 +695,7 @@ struct json_decode<schema::Tuple<T...>, RootSchema, ToDecode> {
 		return void_t{};
 	}
 
-	static error_or<void> decode(buffer_view& buff, data<schema::Tuple<T...>, ToDecode>& to){
+	static error_or<void> decode(buffer_view& buff, data<Schema, ToDecode>& to){
 		assert(buff.read() == '[');
 		buff.read_advance(1);
 
@@ -696,8 +714,10 @@ struct json_decode<schema::Tuple<T...>, RootSchema, ToDecode> {
 };
 
 // The whole std::vector approach is hacky af. ToDo change it maybe?
-template<typename T, size_t D, typename RootSchema, typename ToDecode>
-struct json_decode<schema::Array<T,D>, RootSchema, ToDecode> {
+template<typename T, size_t D, typename ToDecode>
+struct json_decode<schema::Array<T,D>, ToDecode> {
+	using Schema = schema::Array<T,D>;
+
 	template<size_t Level>
 	static error_or<void> decode_flat_level(buffer_view& buff, std::vector<data<T, encode::Native>>& to, std::array<std::size_t, D>& index, std::array<std::size_t, D>& dims, bool log_dim){
 		if constexpr (Level == D) {
@@ -707,7 +727,7 @@ struct json_decode<schema::Array<T,D>, RootSchema, ToDecode> {
 			}catch(std::exception& e){
 				return make_error<err::out_of_memory>();
 			}
-			auto eov = json_decode<T, RootSchema, ToDecode>::decode(buff, to.back());
+			auto eov = json_decode<T, ToDecode>::decode(buff, to.back());
 			if(eov.is_error()){
 				return eov;
 			}
@@ -774,7 +794,7 @@ struct json_decode<schema::Array<T,D>, RootSchema, ToDecode> {
 		return void_t{};
 	}
 
-	static error_or<void> decode(buffer_view& buff, data<schema::Array<T,D>, ToDecode>& to){
+	static error_or<void> decode(buffer_view& buff, data<Schema, ToDecode>& to){
 		std::array<std::size_t, D> index;
 		std::array<std::size_t, D> dims;
 		std::fill(dims.begin(), dims.end(), 0);
-- 
cgit v1.2.3