2 files changed, 101 insertions, 12 deletions

diff --git a/src/codec-json/json.h b/src/codec-json/json.h
index c8456b5..f547e54 100644
--- a/src/codec-json/json.h
+++ b/src/codec-json/json.h
@@ -10,11 +10,6 @@ namespace saw {
 namespace encode {
 struct Json {};
 }
-}
-
-#include "json.tmpl.h"
-
-namespace saw {
 
 template<typename Schema>
 class data<Schema, encode::Json> {
@@ -23,12 +18,14 @@ private:
 public:
 	data():buffer_{}{}
 
+	data(std::size_t ring_size_):buffer_{ring_size_}{}
+
 	buffer& get_buffer(){
 		return buffer_;
 	}
 
-	void push(uint8_t val){
-		buffer_.push(val);
+	error push(uint8_t val){
+		return buffer_.push(val);
 	}
 
 	std::size_t get_size() const {
@@ -43,6 +40,11 @@ public:
 		return buffer_.read(i);
 	}
 };
+}
+
+#include "json.tmpl.h"
+
+namespace saw {
 
 /**
  * Codec class for json
@@ -71,9 +73,16 @@ public:
 	SAW_DEFAULT_MOVE(codec);
 
 	template <typename FromEncoding>
-	error_or<void>  encode(const data<Schema, FromEncoding>& from_encode, data<Schema, encode::Json>& to_encode){
+	error_or<void> encode(const data<Schema, FromEncoding>& from_encode, data<Schema, encode::Json>& to_encode){
 		// To Be encoded
-		return impl::json_encode<Schema, Schema, FromEncoding>::encode(from_encode, to_encode);
+		buffer_view buff_v{to_encode.get_buffer()};
+		auto eov = impl::json_encode<Schema, Schema, FromEncoding>::encode(from_encode, buff_v);
+		if(eov.is_error()){
+			return std::move(eov.get_error());
+		}
+		to_encode.get_buffer().write_advance(buff_v.write_offset());
+
+		return void_t{};
 	}
 
 	template <typename ToEncoding>
diff --git a/src/codec-json/json.tmpl.h b/src/codec-json/json.tmpl.h
index a19e3dc..0738277 100644
--- a/src/codec-json/json.tmpl.h
+++ b/src/codec-json/json.tmpl.h
@@ -10,8 +10,8 @@ class json_encode {
 };
 
 template<typename T, size_t N, typename RootSchema, typename FromEncode>
-struct json_encode<saw::schema::Primitive<T,N>, RootSchema, FromEncode>  {
-	static error_or<void> encode(const data<saw::schema::Primitive<T,N>, FromEncode>& from, data<saw::schema::Primitive<T,N>, encode::Json>& to) {
+struct json_encode<schema::Primitive<T,N>, RootSchema, FromEncode>  {
+	static error_or<void> encode(const data<schema::Primitive<T,N>, 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);
@@ -25,7 +25,7 @@ struct json_encode<saw::schema::Primitive<T,N>, RootSchema, FromEncode>  {
 			++bytes_written;
 		}
 
-		auto& buff = to.get_buffer();
+		auto& buff = to;
 		error err = buff.write_require_length(bytes_written);
 		if(!err.template is_type<err::no_error>()){
 			return std::move(err);
@@ -39,5 +39,85 @@ struct json_encode<saw::schema::Primitive<T,N>, RootSchema, FromEncode>  {
 		return void_t{};
 	}
 };
+
+template<typename RootSchema, typename FromEncode>
+struct json_encode<schema::String, RootSchema, FromEncode>  {
+	static error_or<void> encode(const data<schema::String, 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){
+			auto err = to.push(from.get_at(i));
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+		{
+			auto err = to.push('"');
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
+		}
+
+		return void_t{};
+	}
+};
+
+template<typename... T, typename RootSchema, typename FromEncode>
+struct json_encode<schema::Tuple<T...>, RootSchema, FromEncode>  {
+
+	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);
+
+		if(eov.is_error()){
+			return eov;
+		}
+
+		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::Tuple<T...>, 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{};
+	}
+};
 }
 }