diff options
| -rw-r--r-- | src/codec-json/json.h | 27 | ||||
| -rw-r--r-- | src/codec-json/json.tmpl.h | 86 | ||||
| -rw-r--r-- | src/codec/data.h | 13 | ||||
| -rw-r--r-- | src/core/buffer.cpp | 18 | ||||
| -rw-r--r-- | src/core/buffer.h | 14 | ||||
| -rw-r--r-- | tests/codec-json.cpp | 63 |
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}); } } |