c++, codec-json: Added struct to json encoding and fixed a buffer bug on

the fly

5 files changed, 198 insertions, 10 deletions

diff --git a/src/codec-json/json.tmpl.h b/src/codec-json/json.tmpl.h
index 0738277..38959b2 100644
--- a/src/codec-json/json.tmpl.h
+++ b/src/codec-json/json.tmpl.h
@@ -119,5 +119,113 @@ struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {
 		return void_t{};
 	}
 };
+
+template<typename T, typename RootSchema, typename FromEncode>
+struct json_encode<schema::Array<T>, RootSchema, FromEncode>  {
+	static error_or<void> encode(const data<schema::Array<T>, FromEncode>& from, buffer& to) {
+		{
+			auto err = to.push('[');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+		for(std::size_t i = 0; i < from.size(); ++i){
+			if(i > 0){
+				auto eov_ele = to.push(',');
+				if(!eov_ele.template is_type<err::no_error>()){
+					return eov_ele;
+				}
+			}
+			auto eov = json_encode<T, RootSchema, FromEncode>::encode(from.at(i), to);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		{
+			auto err = to.push(']');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+
+		return void_t{};
+	}
+};
+
+template<typename... T, string_literal... Key, typename RootSchema, typename FromEncode>
+struct json_encode<schema::Struct<schema::Member<T,Key>...>, RootSchema, FromEncode>  {
+
+	template<size_t i>
+	static error_or<void> encode_element(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to){
+		// Encode the name
+		{
+			std::string_view view = parameter_key_pack_type<i, Key...>::literal.view();
+			error err = to.push('"');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+			err = to.push(*reinterpret_cast<const uint8_t *>(view.data()), view.size());
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+			err = to.push('"');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+		// Add the separator
+		{
+			auto eov_ele = to.push(':');
+			if(!eov_ele.template is_type<err::no_error>()){
+				return eov_ele;
+			}
+		}
+	
+		// 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);
+		
+		// Go to the next element
+		if constexpr ( (i+1) < sizeof...(T)){
+			{
+				auto eov_ele = to.push(',');
+				if(!eov_ele.template is_type<err::no_error>()){
+					return eov_ele;
+				}
+			}
+			{
+				auto eov_ele = encode_element<i+1>(from, to);
+				if(eov_ele.is_error()){
+					return eov_ele;
+				}
+			}
+
+
+		}
+
+		return void_t{};
+	}
+	static error_or<void> encode(const data<schema::Struct<schema::Member<T,Key>...>, FromEncode>& from, buffer& to) {
+		{
+			auto err = to.push('{');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+		if constexpr ( sizeof...(T) > 0 ){
+			auto eov = encode_element<0>(from, to);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		{
+			auto err = to.push('}');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+
+		return void_t{};
+	}
+};
 }
 }
diff --git a/src/codec/data.h b/src/codec/data.h
index 63bc752..469e214 100644
--- a/src/codec/data.h
+++ b/src/codec/data.h
@@ -94,6 +94,17 @@ public:
 	, encode::Native>& get(){
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
+	
+	template<string_literal literal>
+	const data<
+		typename parameter_pack_type<
+			parameter_key_pack_index<
+				literal, literals...
+			>::value
+		, T...>::type
+	, encode::Native>& get() const {
+		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
+	}
 
 	constexpr size_t size() const {
 		return sizeof...(T);
@@ -140,8 +151,12 @@ class data<schema::Array<T>, encode::Native> {
 		data<T, encode::Native>& at(size_t i){
 			return value_.at(i);
 		}
+		
+		const data<T, encode::Native>& at(size_t i) const {
+			return value_.at(i);
+		}
 
-		size_t size() const { return value_;}
+		size_t size() const { return value_.size();}
 };
 
 template<>
diff --git a/src/core/error.cpp b/src/core/error.cpp
index 9520972..e777c84 100644
--- a/src/core/error.cpp
+++ b/src/core/error.cpp
@@ -32,7 +32,7 @@ const std::string_view error::get_message() const {
 }
 
 bool error::failed() const {
-	return this->is_type<err::no_error>();
+	return !this->is_type<err::no_error>();
 }
 
 bool error::is_critical() const {
diff --git a/src/core/templates.h b/src/core/templates.h
index 6c0a74e..fcac61b 100644
--- a/src/core/templates.h
+++ b/src/core/templates.h
@@ -53,4 +53,21 @@ struct parameter_key_pack_index {
 				  "Provided string_literal doesn't exist in searched list");
 };
 
+template <size_t i, size_t s, string_literal Key0, string_literal... Keys>
+struct parameter_key_pack_type_helper {
+	static constexpr string_literal literal = parameter_key_pack_type_helper<i, s+1, Keys...>::literal;
+};
+
+template <size_t i, string_literal Key0, string_literal... Keys>
+struct parameter_key_pack_type_helper<i, i, Key0, Keys...> {
+	static constexpr string_literal literal = Key0;
+};
+
+template <size_t i, string_literal... Keys>
+struct parameter_key_pack_type {
+	static constexpr string_literal literal = parameter_key_pack_type_helper<i, 0, Keys...>::literal;
+
+	static_assert(i < sizeof...(Keys), "Provided index is too large in list");
+};
+
 }
diff --git a/tests/codec-json.cpp b/tests/codec-json.cpp
index b5caaa9..67253d7 100644
--- a/tests/codec-json.cpp
+++ b/tests/codec-json.cpp
@@ -4,6 +4,23 @@
 #include <iostream>
 
 namespace {
+namespace schema {
+using namespace saw::schema;
+
+using TestTuple = Tuple<
+	String,
+	Int32
+>;
+
+using TestArray = Array<
+	String
+>;
+
+using TestStruct = Struct<
+	Member<Int32, "foo">,
+	Member<String, "bar">
+>;
+}
 SAW_TEST("Int32 write"){
 	using namespace saw;
 	data<schema::Int32, encode::Native> native_int;
@@ -44,14 +61,6 @@ SAW_TEST("String write"){
 
 	SAW_EXPECT(encoded_value == str_view, "String not encoded correctly");
 }
-namespace schema {
-using namespace saw::schema;
-
-using TestTuple = Tuple<
-	String,
-	Int32
->;
-}
 
 SAW_TEST("Tuple write"){
 	using namespace saw;
@@ -74,4 +83,43 @@ SAW_TEST("Tuple write"){
 
 	SAW_EXPECT(enc_val == str_v, std::string{"Tuple not encoded correctly. Encoded: "} + enc_val + std::string{" Expected: "} + std::string{str_v});
 }
+
+SAW_TEST("Array write"){
+	using namespace saw;
+	data<schema::TestArray, encode::Native> native{3};
+	data<schema::TestArray, encode::Json> json;
+
+	native.at(0).set("foo");
+	native.at(1).set("bar");
+	native.at(2).set("baz");
+
+	codec<schema::TestArray, encode::Json> json_codec;
+
+	error_or<void> eov = json_codec.encode(native, json);
+	SAW_EXPECT(eov.is_value(), "Encoding error");
+
+	std::string_view str_v = "[\"foo\",\"bar\",\"baz\"]";
+	std::string enc_val = convert_to_string(json.get_buffer());
+
+	SAW_EXPECT(enc_val == str_v, std::string{"Array not encoded correctly. Encoded: "} + enc_val + std::string{" Expected: "} + std::string{str_v});
+}
+
+SAW_TEST("Struct write"){
+	using namespace saw;
+	data<schema::TestStruct, encode::Native> native;
+	data<schema::TestStruct, encode::Json> json;
+
+	native.get<"foo">().set(5);
+	native.get<"bar">().set("baz");
+
+	codec<schema::TestStruct, encode::Json> json_codec;
+
+	error_or<void> eov = json_codec.encode(native, json);
+	SAW_EXPECT(eov.is_value(), "Encoding error");
+
+	std::string_view str_v = "{\"foo\":5,\"bar\":\"baz\"}";
+	std::string enc_val = convert_to_string(json.get_buffer());
+
+	SAW_EXPECT(enc_val == str_v, std::string{"Struct not encoded correctly. Encoded: "} + enc_val + std::string{" Expected: "} + std::string{str_v});
+}
 }