diff options
Diffstat (limited to 'src/codec')
| -rw-r--r-- | src/codec/.nix/derivation.nix | 30 | ||||
| -rw-r--r-- | src/codec/SConscript | 38 | ||||
| -rw-r--r-- | src/codec/SConstruct | 66 | ||||
| -rw-r--r-- | src/codec/data.h | 317 | ||||
| -rw-r--r-- | src/codec/forst.h | 13 | ||||
| -rw-r--r-- | src/codec/schema.h | 93 | ||||
| -rw-r--r-- | src/codec/simple.h | 389 | ||||
| -rw-r--r-- | src/codec/stream_value.h | 64 |
8 files changed, 0 insertions, 1010 deletions
diff --git a/src/codec/.nix/derivation.nix b/src/codec/.nix/derivation.nix deleted file mode 100644 index 768dc6e..0000000 --- a/src/codec/.nix/derivation.nix +++ /dev/null @@ -1,30 +0,0 @@ -{ lib -, stdenvNoCC -, scons -, clang -, clang-tools -, version -, forstio -}: - -let - -in stdenvNoCC.mkDerivation { - pname = "forstio-codec"; - inherit version; - src = ./..; - - enableParallelBuilding = true; - - buildInputs = [ - forstio.core - ]; - - nativeBuildInputs = [ - scons - clang - clang-tools - ]; - - outputs = ["out" "dev"]; -} diff --git a/src/codec/SConscript b/src/codec/SConscript deleted file mode 100644 index c038d42..0000000 --- a/src/codec/SConscript +++ /dev/null @@ -1,38 +0,0 @@ -#!/bin/false - -import os -import os.path -import glob - - -Import('env') - -dir_path = Dir('.').abspath - -# Environment for base library -codec_env = env.Clone(); - -codec_env.sources = sorted(glob.glob(dir_path + "/*.cpp")) -codec_env.headers = sorted(glob.glob(dir_path + "/*.h")) - -env.sources += codec_env.sources; -env.headers += codec_env.headers; - -## Shared lib -objects_shared = [] -codec_env.add_source_files(objects_shared, codec_env.sources, shared=True); -codec_env.library_shared = codec_env.SharedLibrary('#build/forstio-codec', [objects_shared]); - -## Static lib -objects_static = [] -codec_env.add_source_files(objects_static, codec_env.sources, shared=False); -codec_env.library_static = codec_env.StaticLibrary('#build/forstio-codec', [objects_static]); - -# Set Alias -env.Alias('library_codec', [codec_env.library_shared, codec_env.library_static]); - -env.targets += ['library_codec']; - -# Install -env.Install('$prefix/lib/', [codec_env.library_shared, codec_env.library_static]); -env.Install('$prefix/include/forstio/codec/', [codec_env.headers]); diff --git a/src/codec/SConstruct b/src/codec/SConstruct deleted file mode 100644 index 0d7b7c6..0000000 --- a/src/codec/SConstruct +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env python3 - -import sys -import os -import os.path -import glob -import re - - -if sys.version_info < (3,): - def isbasestring(s): - return isinstance(s,basestring) -else: - def isbasestring(s): - return isinstance(s, (str,bytes)) - -def add_kel_source_files(self, sources, filetype, lib_env=None, shared=False, target_post=""): - - if isbasestring(filetype): - dir_path = self.Dir('.').abspath - filetype = sorted(glob.glob(dir_path+"/"+filetype)) - - for path in filetype: - target_name = re.sub( r'(.*?)(\.cpp|\.c\+\+)', r'\1' + target_post, path ) - if shared: - target_name+='.os' - sources.append( self.SharedObject( target=target_name, source=path ) ) - else: - target_name+='.o' - sources.append( self.StaticObject( target=target_name, source=path ) ) - pass - -def isAbsolutePath(key, dirname, env): - assert os.path.isabs(dirname), "%r must have absolute path syntax" % (key,) - -env_vars = Variables( - args=ARGUMENTS -) - -env_vars.Add('prefix', - help='Installation target location of build results and headers', - default='/usr/local/', - validator=isAbsolutePath -) - -env=Environment(ENV=os.environ, variables=env_vars, CPPPATH=[], - CPPDEFINES=['SAW_UNIX'], - CXXFLAGS=['-std=c++20','-g','-Wall','-Wextra'], - LIBS=['forstio-core']) -env.__class__.add_source_files = add_kel_source_files -env.Tool('compilation_db'); -env.cdb = env.CompilationDatabase('compile_commands.json'); - -env.objects = []; -env.sources = []; -env.headers = []; -env.targets = []; - -Export('env') -SConscript('SConscript') - -env.Alias('cdb', env.cdb); -env.Alias('all', [env.targets]); -env.Default('all'); - -env.Alias('install', '$prefix') diff --git a/src/codec/data.h b/src/codec/data.h deleted file mode 100644 index 8ff06dc..0000000 --- a/src/codec/data.h +++ /dev/null @@ -1,317 +0,0 @@ -#pragma once - -#include <forstio/core/common.h> -#include <forstio/core/templates.h> - -#include <cassert> - -#include <array> -#include <concepts> -#include <variant> -#include <vector> - -#include "schema.h" - -namespace saw { -namespace encode { -struct Native {}; -} -template<typename Schema, typename Encode> -class codec; -/* - * Helper for the basic message container, so the class doesn't have to be - * specialized 10 times. - */ -template <class T> struct native_data_type; - -template <> -struct native_data_type<schema::Primitive<schema::SignedInteger, 1>> { - using type = int8_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::SignedInteger, 2>> { - using type = int16_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::SignedInteger, 4>> { - using type = int32_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::SignedInteger, 8>> { - using type = int64_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::UnsignedInteger, 1>> { - using type = uint8_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::UnsignedInteger, 2>> { - using type = uint16_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::UnsignedInteger, 4>> { - using type = uint32_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::UnsignedInteger, 8>> { - using type = uint64_t; -}; - -template <> -struct native_data_type<schema::Primitive<schema::FloatingPoint, 4>> { - using type = float; -}; - -template <> -struct native_data_type<schema::Primitive<schema::FloatingPoint, 8>> { - using type = double; -}; - -template<typename T, typename Encoding = encode::Native> -class data { -private: - static_assert(always_false<T>, "Type not supported"); -}; - -template<typename... T, string_literal... literals> -class data<schema::Union<schema::Member<T, literals>...>, encode::Native> { -private: - std::variant<data<T,encode::Native>...> value_; -public: - data() = default; - - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - template<string_literal lit> - void set(data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native> val){ - value_ = std::move(val); - } - - template<string_literal lit> - data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native>& init(){ - value_ = data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native>{}; - return get<lit>(); - } - - template<string_literal lit> - bool holds_alternative() const { - return (parameter_key_pack_index<lit, literals...>::value == value_.index()); - } - - template<string_literal lit> - data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native>& get(){ - return std::get<parameter_key_pack_index<lit, literals...>::value>(value_); - } - - template<string_literal lit> - const data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native>& get() const{ - return std::get<parameter_key_pack_index<lit, literals...>::value>(value_); - } -}; - -template<typename... T, string_literal... literals> -class data<schema::Struct<schema::Member<T, literals>...>, encode::Native> { -private: - std::tuple<data<T,encode::Native>...> value_; -public: - data() = default; - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - template<string_literal literal> - data< - typename parameter_pack_type< - parameter_key_pack_index< - literal, literals... - >::value - , T...>::type - , 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); - } -}; - -template<typename... T> -class data<schema::Tuple<T...>, encode::Native> { -private: - std::tuple<data<T,encode::Native>...> value_; -public: - data() = default; - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - template<size_t 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 { - return sizeof...(T); - } -}; - -template<typename T, size_t Dim> -class data<schema::Array<T,Dim>, encode::Native> { - private: - std::array<std::size_t, Dim> dims_; - std::vector<data<T, encode::Native>> value_; - - std::size_t get_full_size() const { - std::size_t s = 1; - - for(std::size_t iter = 0; iter < Dim; ++iter){ - assert(dims_.at(iter) > 0); - s *= dims_.at(iter); - } - - return s; - } - public: - data() = default; - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - data(const std::array<std::size_t, Dim>& i): - dims_{i}, - value_{} - { - value_.resize(get_full_size()); - } - - template<std::integral... Dims> - data(Dims... size_): - data{{size_...}} - { - static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension"); - } - - data<T, encode::Native>& at(const std::array<std::size_t, Dim>& ind){ - return value_.at(this->get_flat_index(ind)); - } - - const data<T, encode::Native>& at(const std::array<std::size_t, Dim>& ind) const { - return value_.at(this->get_flat_index(ind)); - } - - template<std::integral... Dims> - data<T, encode::Native>& at(Dims... i){ - return value_.at(this->get_flat_index({i...})); - } - - template<std::integral... Dims> - const data<T, encode::Native>& at(Dims... i) const { - return value_.at(this->get_flat_index({i...})); - } - - std::size_t get_dim_size(std::size_t i) const { - return dims_.at(i); - } - - size_t size() const { return value_.size();} - -private: - std::size_t get_flat_index(const std::array<std::size_t, Dim>& i) const { - std::size_t s = 0; - - std::size_t stride = 1; - - for(std::size_t iter = 0; iter < Dim; ++iter){ - s += i.at(iter) * stride; - stride *= dims_.at(iter); - } - - return s; - } -}; - -template<> -class data<schema::String, encode::Native> { -private: - std::string value_; -public: - data() = default; - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - data(std::string value__):value_{std::move(value__)}{} - data(std::size_t size_){ - value_.resize(size_); - } - - std::size_t size() const { - return value_.size(); - } - - void set(std::string str){ - value_ = std::move(str); - } - - char& at(size_t i) { - return value_.at(i); - } - - const char& at(size_t i) const { - return value_.at(i); - } - - char get_at(size_t i) const{ - return value_.at(i); - } - - void set_at(size_t i, char val){ - value_.at(i) = val; - } - - bool operator==(const std::string_view& val)const{ - return value_ == val; - } -}; - -template<typename T, size_t N> -class data<schema::Primitive<T,N>, encode::Native> { -private: - typename native_data_type<schema::Primitive<T,N>>::type value_; -public: - data():value_{{}}{}; - SAW_DEFAULT_COPY(data); - SAW_DEFAULT_MOVE(data); - - data(typename native_data_type<schema::Primitive<T,N>>::type value__): - value_{std::move(value__)}{} - - void set(typename native_data_type<schema::Primitive<T,N>>::type val){ - value_ = val; - } - - typename native_data_type<schema::Primitive<T,N>>::type get() const {return value_;} -}; - - -} diff --git a/src/codec/forst.h b/src/codec/forst.h deleted file mode 100644 index cadf78e..0000000 --- a/src/codec/forst.h +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -#include "data.h" - -namespace saw { -namespace encode { -struct KelForst {}; -} - -class data<schema::String, encode::KelForst> { - -}; -} diff --git a/src/codec/schema.h b/src/codec/schema.h deleted file mode 100644 index 2f63fe9..0000000 --- a/src/codec/schema.h +++ /dev/null @@ -1,93 +0,0 @@ -#pragma once - -#include <forstio/core/common.h> -#include <forstio/core/string_literal.h> - -namespace saw { -namespace schema { -// NOLINTBEGIN -template <typename T, string_literal Literal> struct Member {}; - -template <typename... T> struct Struct { - static_assert( - always_false<T...>, - "This schema template doesn't support this type of template argument"); -}; - -template <typename... V, string_literal... K> -struct Struct<Member<V, K>...> {}; - -template <typename... T> struct Union { - static_assert( - always_false<T...>, - "This schema template doesn't support this type of template argument"); -}; - -template <typename... V, string_literal... K> -struct Union<Member<V, K>...> {}; - -template <typename T, size_t Dim = 1> struct Array {}; - -template <class T> struct is_array { - constexpr static bool value = false; -}; - -template <class T, size_t Dim> struct is_array<schema::Array<T,Dim>> { - constexpr static bool value = true; -}; - -template<typename T, size_t... S> struct FixedArray {}; - -template <typename... T> struct Tuple {}; - -/** - * This acts as a separator of different encodings being mashed together - */ -template <typename T, typename Enc> -class Wrapper {}; - -struct String {}; - -struct SignedInteger {}; -struct UnsignedInteger {}; -struct FloatingPoint {}; - -template <class T, size_t N> struct Primitive { - static_assert(((std::is_same_v<T, SignedInteger> || - std::is_same_v<T, UnsignedInteger>)&&(N == 1 || N == 2 || - N == 4 || N == 8)) || - (std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)), - "Primitive Type is not supported"); -}; - -using Int8 = Primitive<SignedInteger, 1>; -using Int16 = Primitive<SignedInteger, 2>; -using Int32 = Primitive<SignedInteger, 4>; -using Int64 = Primitive<SignedInteger, 8>; - -using UInt8 = Primitive<UnsignedInteger, 1>; -using UInt16 = Primitive<UnsignedInteger, 2>; -using UInt32 = Primitive<UnsignedInteger, 4>; -using UInt64 = Primitive<UnsignedInteger, 8>; - -using Float32 = Primitive<FloatingPoint, 4>; -using Float64 = Primitive<FloatingPoint, 8>; - -/** - * Classes enabling Rpc calls - */ -template <class Request, class Response, string_literal Literal> -struct Function {}; - -template <class... T> struct Interface { - static_assert( - always_false<T...>, - "This schema template doesn't support this type of template argument"); -}; - -template <class... Request, class... Response, string_literal... Literal> -struct Interface<Function<Request, Response, Literal>...> {}; - -// NOLINTEND -} // namespace schema -} // namespace saw diff --git a/src/codec/simple.h b/src/codec/simple.h deleted file mode 100644 index 8760754..0000000 --- a/src/codec/simple.h +++ /dev/null @@ -1,389 +0,0 @@ -#pragma once - -#include "data.h" -#include "stream_value.h" - -#include <forstio/core/buffer.h> -#include <forstio/core/error.h> - -namespace saw { -namespace encode { -struct KelSimple {}; -} - -template<typename T> -class data<T, encode::KelSimple> { -private: - ring_buffer buffer_; -public: - data() = default; - - buffer& get_buffer(){ - return buffer_; - } -}; - -namespace impl { -template<typename Schema, typename FromEnc> -class kelsimple_encode { - static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding."); -}; - -template<typename T, size_t N, typename FromEnc> -struct kelsimple_encode<schema::Primitive<T,N>, FromEnc> { - static error_or<void> encode(const data<schema::Primitive<T,N>, FromEnc>& from, buffer& to){ - auto eov = stream_value<schema::Primitive<T,N>>::encode(from.get(), to); - return eov; - } -}; - -template<typename T, size_t Dim, typename FromEnc> -struct kelsimple_encode<schema::Array<T,Dim>, FromEnc> { - template<std::size_t Level> - static error_or<void> encode_level(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to, std::array<std::size_t, Dim>& index){ - if constexpr (Dim == Level){ - return kelsimple_encode<T,FromEnc>::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<Level+1>(from, to, index); - if(eov.is_error()){ - return eov; - } - } - } - return void_t{}; - } - - static error_or<void> encode(const data<schema::Array<T,Dim>, FromEnc>& from, buffer& to){ - { - for(uint64_t i = 0; i < Dim; ++i){ - auto eov = stream_value<schema::UInt64>::encode(from.get_dim_size(i), to); - if(eov.is_error()){ - return eov; - } - } - } - { - std::array<std::size_t, Dim> index; - std::fill(index.begin(), index.end(), 0); - - return encode_level<0>(from, to, index); - } - return void_t{}; - } -}; - -template<typename... T, string_literal... Lits, typename FromEnc> -struct kelsimple_encode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> { - template<std::size_t i> - static error_or<void> encode_member(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){ - using Type = typename parameter_pack_type<i,T...>::type; - constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal; - { - auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<Literal>(), to); - if(eov.is_error()){ - return eov; - } - } - if constexpr ((i+1) < sizeof...(T)){ - auto eov = encode_member<i+1>(from, to); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - } - - static error_or<void> encode(const data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){ - return encode_member<0>(from, to); - } -}; - -template<typename... T, string_literal... Lits, typename FromEnc> -struct kelsimple_encode<schema::Union<schema::Member<T,Lits>...>,FromEnc> { - template<std::size_t i> - static error_or<void> encode_member(const data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){ - using Type = typename parameter_pack_type<i,T...>::type; - constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal; - if (from.template holds_alternative<Literal>()) { - { - auto eov = stream_value<schema::UInt64>::encode(static_cast<uint64_t>(i), to); - if(eov.is_error()){ - return eov; - } - } - { - auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<Literal>(), to); - if(eov.is_error()){ - return eov; - } - } - } - - if constexpr ( (i+1) < sizeof...(T) ){ - auto eov = encode_member<i+1>(from, to); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - } - - static error_or<void> encode(const data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& from, buffer& to){ - return encode_member<0>(from, to); - } -}; - -template<typename... T, typename FromEnc> -struct kelsimple_encode<schema::Tuple<T...>, FromEnc> { - template<std::size_t i> - static error_or<void> encode_member(const data<schema::Tuple<T...>, FromEnc>& from, buffer& to){ - using Type = typename parameter_pack_type<i,T...>::type; - { - auto eov = kelsimple_encode<Type, FromEnc>::encode(from.template get<i>(), to); - } - if constexpr ((i+1) < sizeof...(T)){ - auto eov = encode_member<i+1>(from, to); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - } - - static error_or<void> encode(const data<schema::Tuple<T...>, FromEnc>& from, buffer& to){ - return encode_member<0>(from, to); - } -}; - -template<typename FromEnc> -struct kelsimple_encode<schema::String, FromEnc> { - static error_or<void> encode(const data<schema::String, FromEnc>& from, buffer& to){ - const auto str_size = from.size(); - typename native_data_type<schema::UInt64>::type str_len = static_cast<uint64_t>(str_size); - { - auto eov = stream_value<schema::UInt64>::encode(str_len, to); - if(eov.is_error()){ - return eov; - } - } - - for(std::size_t i = 0; i < str_size; ++i){ - auto eov = stream_value<schema::Int8>::encode(from.at(i), to); - if(eov.is_error()){ - return eov; - } - } - - return void_t{}; - } -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -template<typename Schema, typename FromEnc> -class kelsimple_decode { - static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the kelsimple encoding."); -}; - -template<typename T, size_t N, typename FromEnc> -struct kelsimple_decode<schema::Primitive<T,N>, FromEnc> { - static error_or<void> decode(buffer& from, data<schema::Primitive<T,N>, FromEnc>& to){ - typename native_data_type<schema::Primitive<T,N>>::type val{}; - auto eov = stream_value<schema::Primitive<T,N>>::decode(val, from); - if (eov.is_value()) { - to.set(val); - } - return eov; - } - -}; - -template<typename T, size_t Dim, typename FromEnc> -struct kelsimple_decode<schema::Array<T,Dim>, FromEnc> { - template<std::size_t Level> - static error_or<void> decode_level(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to, std::array<std::size_t, Dim>& index){ - if constexpr (Level == Dim){ - return kelsimple_decode<T, FromEnc>::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<Level+1>(from, to, index); - if(eov.is_error()){ - return eov; - } - } - } - return void_t{}; - } - - static error_or<void> decode(buffer& from, data<schema::Array<T,Dim>, FromEnc>& to){ - { - std::array<std::size_t, Dim> dims{}; - for(std::size_t i = 0; i < Dim; ++i){ - uint64_t val{}; - auto eov = stream_value<schema::UInt64>::decode(val, from); - if(eov.is_error()){ - return eov; - } - dims.at(i) = static_cast<std::size_t>(val); - } - to = data<schema::Array<T,Dim>,FromEnc>{dims}; - } - { - std::array<std::size_t, Dim> index{}; - return decode_level<0>(from, to, index); - } - return void_t{}; - } -}; -template<typename... T, string_literal... Lits, typename FromEnc> -struct kelsimple_decode<schema::Struct<schema::Member<T,Lits>...>,FromEnc> { - template<std::size_t i> - static error_or<void> decode_member(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){ - using Type = typename parameter_pack_type<i,T...>::type; - constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal; - { - auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<Literal>()); - if(eov.is_error()){ - return eov; - } - } - if constexpr ((i+1) < sizeof...(T)){ - auto eov = decode_member<i+1>(from, to); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - - } - static error_or<void> decode(buffer& from, data<schema::Struct<schema::Member<T,Lits>...>, FromEnc>& to){ - return decode_member<0>(from, to); - } - -}; - -template<typename... T, string_literal... Lits, typename FromEnc> -struct kelsimple_decode<schema::Union<schema::Member<T,Lits>...>,FromEnc> { - template<uint64_t i> - static error_or<void> decode_member(buffer& from, data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& to, uint64_t val){ - using Type = typename parameter_pack_type<i,T...>::type; - constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal; - - if( i == val ){ - to.template set<Literal>(data<Type, FromEnc>{}); - auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<Literal>()); - if(eov.is_error()){ - return eov; - } - return void_t{}; - } - - if constexpr ((i+1) < sizeof...(T)){ - auto eov = decode_member<i+1>(from, to, val); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - - } - static error_or<void> decode(buffer& from, data<schema::Union<schema::Member<T,Lits>...>, FromEnc>& to){ - uint64_t val{}; - auto eov = stream_value<schema::UInt64>::decode(val, from); - if(eov.is_error()){ - return eov; - } - if ( val >= sizeof...(T) ){ - return make_error<err::invalid_state>(); - } - return decode_member<0>(from, to, val); - } - -}; - -template<typename... T, typename FromEnc> -struct kelsimple_decode<schema::Tuple<T...>,FromEnc> { - template<std::size_t i> - static error_or<void> decode_member(buffer& from, data<schema::Tuple<T...>, FromEnc>& to){ - using Type = typename parameter_pack_type<i,T...>::type; - { - auto eov = kelsimple_decode<Type, FromEnc>::decode(from, to.template get<i>()); - } - if constexpr ((i+1) < sizeof...(T)){ - auto eov = decode_member<i+1>(from, to); - if(eov.is_error()){ - return eov; - } - } - return void_t{}; - - } - static error_or<void> decode(buffer& from, data<schema::Tuple<T...>, FromEnc>& to){ - return decode_member<0>(from, to); - } - -}; -template<typename FromEnc> -struct kelsimple_decode<schema::String, FromEnc> { - static error_or<void> decode(buffer& from, data<schema::String, FromEnc>& to){ - { - uint64_t val{}; - auto eov = stream_value<schema::UInt64>::decode(val, from); - if(eov.is_error()){ - return eov; - } - to = data<schema::String,FromEnc>{val}; - } - const std::size_t str_size = to.size(); - for(std::size_t i = 0; i < str_size; ++i){ - int8_t val{}; - auto eov = stream_value<schema::Int8>::decode(val, from); - if(eov.is_error()){ - return eov; - } - to.set_at(i, val); - } - return void_t{}; - } -}; - -} - -template<typename Schema> -class codec<Schema, encode::KelSimple> { -public: - struct config { - size_t depth = 16; - size_t length = 1024; - }; -private: - config cfg_; -public: - codec() = default; - - SAW_FORBID_COPY(codec); - SAW_DEFAULT_MOVE(codec); - - template<typename FromEnc> - error_or<void> encode(const data<Schema, FromEnc>& from_enc, data<Schema, encode::KelSimple>& to_enc){ - buffer_view buff_v{to_enc.get_buffer()}; - - auto eov = impl::kelsimple_encode<Schema, FromEnc>::encode(from_enc, buff_v); - - to_enc.get_buffer().write_advance(buff_v.write_offset()); - - return eov; - } - - template<typename ToDec> - error_or<void> decode(data<Schema, encode::KelSimple>& from_dec, data<Schema, ToDec>& to){ - buffer_view buff_v{from_dec.get_buffer()}; - - auto eov = impl::kelsimple_decode<Schema,ToDec>::decode(buff_v, to); - - return eov; - } -}; -} diff --git a/src/codec/stream_value.h b/src/codec/stream_value.h deleted file mode 100644 index 09203cb..0000000 --- a/src/codec/stream_value.h +++ /dev/null @@ -1,64 +0,0 @@ -#pragma once - -#include "schema.h" - -#include <forstio/core/buffer.h> -#include <forstio/core/error.h> - -#include <cstdint> -#include <cstring> - -namespace saw { -/** - * Helper class to encode/decode any primtive type into/from litte endian. - * The shift class does this by shifting bytes. This type of procedure is - * platform independent. So it does not matter if the memory layout is - * little endian or big endian - */ -template<typename T> class shift_stream_value { - static_assert(always_false<T>, "Shift Stream Value only supports Primitives"); -}; - -template <typename T, size_t N> class shift_stream_value<schema::Primitive<T,N>> { -public: - inline static error_or<void> decode(typename native_data_type<schema::Primitive<T,N>>::type &val, buffer &buff) { - if (buff.read_composite_length() < N) { - return make_error<err::buffer_exhausted>(); - } - - typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw = 0; - - for (size_t i = 0; i < N; ++i) { - raw |= (static_cast<typename native_data_type<schema::Primitive<T,N>>::type>(buff.read(i)) << (i * 8)); - } - - memcpy(&val, &raw, N); - buff.read_advance(N); - - return void_t{}; - } - - inline static error_or<void> encode(const typename native_data_type<schema::Primitive<T,N>>::type &val, buffer &buff) { - error err = buff.write_require_length(N); - if (err.failed()) { - return err; - } - - typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw{}; - memcpy(&raw, &val, N); - - for (size_t i = 0; i < N; ++i) { - buff.write(i) = raw >> (i * 8); - } - - buff.write_advance(N); - - return void_t{}; - } - - inline static size_t size() { return N; } -}; - -template <typename T> using stream_value = shift_stream_value<T>; - -} // namespace saw |