From 44b97c0c13c3cb05a5fed70326285b45bc7b37a6 Mon Sep 17 00:00:00 2001 From: Claudius Holeksa Date: Mon, 26 Jun 2023 15:25:29 +0200 Subject: c++,codec: Added kelsimple array and struct decoding / encoding --- src/codec/data.h | 14 ++-- src/codec/simple.h | 166 +++++++++++++++++++++++++++++++++++++++++++++-- src/codec/stream_value.h | 34 ++++++---- 3 files changed, 189 insertions(+), 25 deletions(-) (limited to 'src') diff --git a/src/codec/data.h b/src/codec/data.h index 5cb1267..a43fdd8 100644 --- a/src/codec/data.h +++ b/src/codec/data.h @@ -195,16 +195,18 @@ class data, encode::Native> { SAW_DEFAULT_COPY(data); SAW_DEFAULT_MOVE(data); + data(const std::array& i): + dims_{i}, + value_{} + { + value_.resize(get_full_size()); + } + template data(Dims... size_): - dims_{size_...}, - value_{} + data{{size_...}} { - for(auto& iter : dims_){ - assert(iter > 0); - } static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension"); - value_.resize(get_full_size()); } data& at(const std::array& ind){ diff --git a/src/codec/simple.h b/src/codec/simple.h index 1b6cf0d..ad66f66 100644 --- a/src/codec/simple.h +++ b/src/codec/simple.h @@ -1,6 +1,12 @@ #pragma once #include "data.h" +#include "stream_value.h" + +#include + +#include +#include namespace saw { namespace encode { @@ -15,7 +21,7 @@ public: data() = default; buffer& get_buffer(){ - return buffer; + return buffer_; } }; @@ -25,13 +31,152 @@ class kelsimple_encode { static_assert(always_false, "This schema type is not being handled by the kelsimple encoding."); }; -template +template struct kelsimple_encode, FromEnc> { static error_or encode(const data, FromEnc>& from, buffer& to){ - + auto eov = stream_value>::encode(from.get(), to); + return eov; + } +}; + +template +struct kelsimple_encode, FromEnc> { + template + static error_or encode_level(const data, FromEnc>& from, buffer& to, std::array& index){ + if constexpr (Dim == Level){ + return kelsimple_encode::encode(from.at(index), to); + } else { + const std::size_t dim_size = from.get_dim_size(Level); + for(index[Level] = 0; (index.at(Level) < dim_size); ++index[Level]){ + auto eov = encode_level(from, to, index); + if(eov.is_error()){ + return eov; + } + } + } + return void_t{}; + } + + static error_or encode(const data, FromEnc>& from, buffer& to){ + { + for(uint64_t i = 0; i < Dim; ++i){ + auto eov = stream_value::encode(from.get_dim_size(i), to); + if(eov.is_error()){ + return eov; + } + } + } + { + std::array index; + std::fill(index.begin(), index.end(), 0); + + return encode_level<0>(from, to, index); + } + return void_t{}; + } +}; + +template +struct kelsimple_encode...>,FromEnc> { + template + static error_or encode_member(const data...>, FromEnc>& from, buffer& to){ + using Type = typename parameter_pack_type::type; + constexpr string_literal Literal = parameter_key_pack_type::literal; + { + auto eov = kelsimple_encode::encode(from.template get(), to); + } + if constexpr ((i+1) < sizeof...(T)){ + auto eov = encode_member(from, to); + if(eov.is_error()){ + return eov; + } + } + return void_t{}; + } + + static error_or encode(const data...>, FromEnc>& from, buffer& to){ + return encode_member<0>(from, to); + } +}; + +template +class kelsimple_decode { + static_assert(always_false, "This schema type is not being handled by the kelsimple encoding."); +}; + +template +struct kelsimple_decode, FromEnc> { + static error_or decode(buffer& from, data, FromEnc>& to){ + typename native_data_type>::type val{}; + auto eov = stream_value>::decode(val, from); + if (eov.is_value()) { + to.set(val); + } + return eov; + } + +}; +template +struct kelsimple_decode, FromEnc> { + template + static error_or decode_level(buffer& from, data, FromEnc>& to, std::array& index){ + if constexpr (Level == Dim){ + return kelsimple_decode::decode(from, to.at(index)); + }else{ + const std::size_t dim_size = to.get_dim_size(Level); + for(index[Level] = 0; index[Level] < dim_size; ++index[Level]){ + auto eov = decode_level(from, to, index); + if(eov.is_error()){ + return eov; + } + } + } + return void_t{}; + } + + static error_or decode(buffer& from, data, FromEnc>& to){ + { + std::array dims{}; + for(std::size_t i = 0; i < Dim; ++i){ + uint64_t val{}; + auto eov = stream_value::decode(val, from); + if(eov.is_error()){ + return eov; + } + dims.at(i) = static_cast(val); + } + to = data,FromEnc>{dims}; + } + { + std::array index{}; + return decode_level<0>(from, to, index); + } + return void_t{}; + } +}; +template +struct kelsimple_decode...>,FromEnc> { + template + static error_or decode_member(buffer& from, data...>, FromEnc>& to){ + using Type = typename parameter_pack_type::type; + constexpr string_literal Literal = parameter_key_pack_type::literal; + { + auto eov = kelsimple_decode::decode(from, to.template get()); + } + if constexpr ((i+1) < sizeof...(T)){ + auto eov = decode_member(from, to); + if(eov.is_error()){ + return eov; + } + } return void_t{}; + } + static error_or decode(buffer& from, data...>, FromEnc>& to){ + return decode_member<0>(from, to); + } + }; } @@ -54,9 +199,20 @@ public: error_or encode(const data& from_enc, data& to_enc){ buffer_view buff_v{to_enc.get_buffer()}; - auto eov = kelsimple_encode::encode(from_env, buff_v); + auto eov = impl::kelsimple_encode::encode(from_enc, buff_v); - return void_t{}; + to_enc.get_buffer().write_advance(buff_v.write_offset()); + + return eov; + } + + template + error_or decode(data& from_dec, data& to){ + buffer_view buff_v{from_dec.get_buffer()}; + + auto eov = impl::kelsimple_decode::decode(buff_v, to); + + return eov; } }; } diff --git a/src/codec/stream_value.h b/src/codec/stream_value.h index df1334b..09203cb 100644 --- a/src/codec/stream_value.h +++ b/src/codec/stream_value.h @@ -1,7 +1,9 @@ #pragma once -#include "buffer.h" -#include "error.h" +#include "schema.h" + +#include +#include #include #include @@ -13,44 +15,48 @@ namespace saw { * platform independent. So it does not matter if the memory layout is * little endian or big endian */ -template class ShiftStreamValue { +template class shift_stream_value { + static_assert(always_false, "Shift Stream Value only supports Primitives"); +}; + +template class shift_stream_value> { public: inline static error_or decode(typename native_data_type>::type &val, buffer &buff) { - if (buff.read_composite_length() < sizeof(T)) { + if (buff.read_composite_length() < N) { return make_error(); } typename native_data_type>::type raw = 0; - for (size_t i = 0; i < sizeof(T); ++i) { - raw |= (static_cast(buff.read(i)) << (i * 8)); + for (size_t i = 0; i < N; ++i) { + raw |= (static_cast>::type>(buff.read(i)) << (i * 8)); } - memcpy(&val, &raw, sizeof(T)); - buff.read_advance(sizeof(T)); + memcpy(&val, &raw, N); + buff.read_advance(N); return void_t{}; } inline static error_or encode(const typename native_data_type>::type &val, buffer &buff) { - error err = buff.write_require_length(sizeof(T)); + error err = buff.write_require_length(N); if (err.failed()) { return err; } typename native_data_type>::type raw{}; - memcpy(&raw, &val, sizeof(T)); + memcpy(&raw, &val, N); - for (size_t i = 0; i < sizeof(T); ++i) { - buffer.write(i) = raw >> (i * 8); + for (size_t i = 0; i < N; ++i) { + buff.write(i) = raw >> (i * 8); } - buffer.write_advance(sizeof(T)); + buff.write_advance(N); return void_t{}; } - inline static size_t size() const { return N; } + inline static size_t size() { return N; } }; template using stream_value = shift_stream_value; -- cgit v1.2.3