c++, codec-json: Added testing for tuples and fixed minor buffer

changes

6 files changed, 190 insertions, 31 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{};
+	}
+};
 }
 }
diff --git a/src/codec/data.h b/src/codec/data.h
index 895a2fb..63bc752 100644
--- a/src/codec/data.h
+++ b/src/codec/data.h
@@ -110,8 +110,13 @@ public:
 	SAW_DEFAULT_MOVE(data);
 	
 	template<size_t i>
-	data<typename parameter_pack_type<i>::type, encode::Native>& get(){
-		return std::get<i>();
+	data<typename parameter_pack_type<i,T...>::type, encode::Native>& get(){
+		return std::get<i>(value_);
+	}
+	
+	template<size_t i>
+	const data<typename parameter_pack_type<i,T...>::type, encode::Native>& get() const{
+		return std::get<i>(value_);
 	}
 
 	constexpr size_t size() const {
@@ -154,6 +159,10 @@ public:
 		return value_.size();
 	}
 
+	void set(std::string str){
+		value_ = std::move(str);
+	}
+
 	char get_at(size_t i) const{
 		return value_.at(i);
 	}
diff --git a/src/core/buffer.cpp b/src/core/buffer.cpp
index 81fc0df..15f4cae 100644
--- a/src/core/buffer.cpp
+++ b/src/core/buffer.cpp
@@ -60,14 +60,7 @@ error buffer::pop(uint8_t &buffer, size_t size) {
 	return no_error();
 }
 
-std::string buffer::to_string() const {
-	std::ostringstream oss;
-	for (size_t i = 0; i < read_composite_length(); ++i) {
-		oss << read(i);
-	}
-	return oss.str();
-}
-
+/*
 std::string buffer::to_hex() const {
 	std::ostringstream oss;
 	oss << std::hex << std::setfill('0');
@@ -79,6 +72,15 @@ std::string buffer::to_hex() const {
 	}
 	return oss.str();
 }
+*/
+
+std::string convert_to_string(const buffer& buff){
+	std::ostringstream oss;
+	for (size_t i = 0; i < buff.read_composite_length(); ++i) {
+		oss << buff.read(i);
+	}
+	return oss.str();
+}
 
 buffer_view::buffer_view(buffer &buffer)
 	: buffer_{&buffer}, read_offset_{0}, write_offset_{0} {}
diff --git a/src/core/buffer.h b/src/core/buffer.h
index ff39aff..f0cf76e 100644
--- a/src/core/buffer.h
+++ b/src/core/buffer.h
@@ -47,13 +47,17 @@ public:
 	error pop(uint8_t &value);
 	error pop(uint8_t &buffer, size_t size);
 
-	/*
-	 * Subject to change
-	 */
-	std::string to_string() const;
-	std::string to_hex() const;
 };
 
+/**
+ * Converts a buffer to a string for convenience cases
+ */
+std::string convert_to_string(const buffer& buf);
+
+/**
+ *
+ */
+
 /*
  *	A viewer class for buffers.
  *	Working on the reference buffer invalidates the buffer view
diff --git a/tests/codec-json.cpp b/tests/codec-json.cpp
index d82db14..b5caaa9 100644
--- a/tests/codec-json.cpp
+++ b/tests/codec-json.cpp
@@ -1,6 +1,8 @@
 #include <forstio/test/suite.h>
 #include <forstio/codec/json/json.h>
 
+#include <iostream>
+
 namespace {
 SAW_TEST("Int32 write"){
 	using namespace saw;
@@ -14,9 +16,62 @@ SAW_TEST("Int32 write"){
 	error_or<void> eov = json_codec.encode(native_int, json_int);
 	SAW_EXPECT(eov.is_value(), "Encoding error");
 
-	std::string_view str_view = "44123";
-	for(std::size_t i = 0; i < str_view.size(); ++i){
-		SAW_EXPECT( json_int.at(i) == str_view[i], "Value is not being encoded correctly" );
-	}
+	/**
+	 * Currently doing this manually. Technically I should convert to std::string for tests
+	 */
+	std::string_view str_v = "44123";
+	std::string enc_val = convert_to_string(json_int.get_buffer());
+	SAW_EXPECT( enc_val == str_v, std::string{"Value is not being encoded correctly. Encoded: "} + enc_val );
+}
+
+SAW_TEST("String write"){
+	using namespace saw;
+	data<schema::String, encode::Native> nat_str;
+	data<schema::String, encode::Json> json_str;
+
+	nat_str.set("foo");
+
+	codec<schema::String, encode::Json> json_codec;
+
+	error_or<void> eov = json_codec.encode(nat_str, json_str);
+	SAW_EXPECT(eov.is_value(), "Encoding error");
+
+	/**
+	 * Currently doing this manually. Technically I should convert to std::string for tests
+	 */
+	std::string_view str_view = "\"foo\"";
+	std::string encoded_value = convert_to_string(json_str.get_buffer());
+
+	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;
+	data<schema::TestTuple, encode::Native> native_tup;
+	data<schema::TestTuple, encode::Json> json_tup;
+
+	auto& nat_zero = native_tup.template get<0>();
+	auto& nat_one = native_tup.template get<1>();
+	
+	nat_zero.set("bar");
+	nat_one.set(34);
+	
+	codec<schema::TestTuple, encode::Json> json_codec;
+
+	error_or<void> eov = json_codec.encode(native_tup, json_tup);
+	SAW_EXPECT(eov.is_value(), "Encoding error");
+
+	std::string_view str_v = "[\"bar\",34]";
+	std::string enc_val = convert_to_string(json_tup.get_buffer());
+
+	SAW_EXPECT(enc_val == str_v, std::string{"Tuple not encoded correctly. Encoded: "} + enc_val + std::string{" Expected: "} + std::string{str_v});
 }
 }