summaryrefslogtreecommitdiff
path: root/c++/codec
diff options
context:
space:
mode:
Diffstat (limited to 'c++/codec')
-rw-r--r--c++/codec/.nix/derivation.nix28
-rw-r--r--c++/codec/SConscript38
-rw-r--r--c++/codec/SConstruct66
-rw-r--r--c++/codec/args.h123
-rw-r--r--c++/codec/csv.h25
-rw-r--r--c++/codec/data.h370
-rw-r--r--c++/codec/forst.h32
-rw-r--r--c++/codec/forst.tmpl.h7
-rw-r--r--c++/codec/interface.h103
-rw-r--r--c++/codec/rpc.h26
-rw-r--r--c++/codec/schema.h109
-rw-r--r--c++/codec/schema_hash.h105
-rw-r--r--c++/codec/schema_stringify.h118
-rw-r--r--c++/codec/simple.h389
-rw-r--r--c++/codec/stream_value.h64
15 files changed, 0 insertions, 1603 deletions
diff --git a/c++/codec/.nix/derivation.nix b/c++/codec/.nix/derivation.nix
deleted file mode 100644
index bcf2be7..0000000
--- a/c++/codec/.nix/derivation.nix
+++ /dev/null
@@ -1,28 +0,0 @@
-{ lib
-, stdenv
-, scons
-, clang-tools
-, version
-, forstio
-}:
-
-let
-
-in stdenv.mkDerivation {
- pname = "forstio-codec";
- inherit version;
- src = ./..;
-
- enableParallelBuilding = true;
-
- buildInputs = [
- forstio.core
- ];
-
- nativeBuildInputs = [
- scons
- clang-tools
- ];
-
- outputs = ["out" "dev"];
-}
diff --git a/c++/codec/SConscript b/c++/codec/SConscript
deleted file mode 100644
index c038d42..0000000
--- a/c++/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/c++/codec/SConstruct b/c++/codec/SConstruct
deleted file mode 100644
index 0d7b7c6..0000000
--- a/c++/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/c++/codec/args.h b/c++/codec/args.h
deleted file mode 100644
index 6bb75a2..0000000
--- a/c++/codec/args.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#pragma once
-
-#include "schema.h"
-
-namespace saw {
-namespace encode {
-struct Args {};
-}
-
-namespace schema {
-template<typename InnerSchemaStruct, typename InnerSchemaTuple>
-using Args = Struct<
- Member<String, "program">,
- Member<InnerSchemaStruct, "args">,
- Member<InnerSchemaTuple, "positionals">
->;
-}
-
-template<typename T>
-class data<T, encode::Args> {
- static_assert(always_false<T>,"Not supported. Use the schema::Args alias or check how it's defined.");
-};
-
-template<typename... Str, string_literal... Lits, typename... Tup>
-class data<schema::Args<schema::Struct<schema::Member<Str,Lits>...>, schema::Tuple<Tup...>>, encode::Args> {
-private:
- char** argv_;
- int argc_;
-public:
- data(char** argv, int argc):
- argv_{argv},
- argc_{argc}
- {}
-
- size_t size() const {
- if(argc_ < 0){
- return 0;
- }
-
- static_assert(sizeof(int) <= sizeof(size_t), "size_t is smaller than int");
-
- return static_cast<size_t>(argc_);
- }
-
- std::string_view arg_view(size_t i){
- if(i < size()){
- return std::string_view{argv_[i]};
- }
- return "";
- }
-};
-
-namespace impl {
-template<typename T, typename ToDec>
-struct args_decode {
- static_assert(always_false<T,ToDec>, "Not supported");
-};
-
-template<typename... Str, string_literal... Lits, typename... Tup, typename ToDec>
-struct args_decode<schema::Args<schema::Struct<schema::Member<Str,Lits>...>,schema::Tuple<Tup...>>,ToDec> {
- using Schema = schema::Args<
- schema::Struct<schema::Member<Str,Lits>...>,
- schema::Tuple<Tup...>
- >;
-
- static error_or<void> decode(data<Schema, encode::Args>& from, data<Schema,ToDec>& to){
- if(from.size() == 0){
- return make_error<err::invalid_state>();
- }
-
- to.get<"program">().set(std::string{from.arg_view(0)});
- std::size_t tuple_pos = 0;
- for(size_t i = 1; i < from.size(); ++i){
- auto view = from.arg_view(i);
- if(view.starts_with("--")){
- view.remove_prefix(std::min(2u, view.size()));
- ++i;
-
- if( i >= from.size() ){
- return make_error<err::invalid_state>();
- }
-
- auto value_view = from.arg_view(i);
-
- auto eov = decode_struct_member<0>(to.get<"args">(), view, value_view);
- if(eov.is_error()){
- return eov;
- }
- } else {
- auto eov = decode_tuple_member<0>(to.get<"positionals">(), view);
- if(eov.is_error()){
- return eov;
- }
- ++tuple_pos;
- }
- }
-
- if(tuple_pos != sizeof...(Tup)){
- return make_error<err::invalid_state>();
- }
-
- return void_t{};
- }
-};
-}
-
-template<typename Schema>
-class codec<Schema, encode::Args> {
-public:
- template<typename ToDec>
- error_or<void> decode(data<Schema, encode::Args>& from, data<Schema, ToDec>& to){
- struct name_and_value {
- std::string name;
- std::string value;
- };
- std::string program;
- std::vector<name_and_value> navs;
- std::vector<std::string> positionals;
-
- return void_t{};
- }
-};
-}
diff --git a/c++/codec/csv.h b/c++/codec/csv.h
deleted file mode 100644
index 67c2c1d..0000000
--- a/c++/codec/csv.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "data.h"
-
-namespace saw {
-namespace encode {
-struct Csv {};
-}
-
-template<typename Schema>
-class codec<Schema, encode::Csv> {
-public:
- template<typename FromEncode>
- static error_or<void> encode(const data<Schema, FromEncode>& from, data<Schema,encode::Csv>& to){
-
- return make_error<err::not_implemented>();
- }
-
- template<typename ToDecode>
- static error_or<void> decode(data<Schema,encode::Csv>& from, data<Schema, FromEncode>& to){
-
- return make_error<err::not_implemented>();
- }
-};
-}
diff --git a/c++/codec/data.h b/c++/codec/data.h
deleted file mode 100644
index 237ef5a..0000000
--- a/c++/codec/data.h
+++ /dev/null
@@ -1,370 +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){
- assert(i.at(iter) < dims_.at(iter));
- s += i.at(iter) * stride;
- stride *= dims_.at(iter);
- }
-
- return s;
- }
-};
-
-template<typename T, std::size_t... D>
-class data<schema::FixedArray<T,D...>, encode::Native> {
-private:
- //using inner_type = std::array<data<T, encode::Native>, multiply_helper<Dims...>::value>;
- //std::unique_ptr<inner_type> value_;
- std::vector<data<T, encode::Native>> value_;
-
-public:
- data(){
- value_.resize(ct_multiply<std::size_t, D...>::value);
- }
-
- data<T, encode::Native>& at(const std::array<std::size_t, sizeof...(D)>& ind){
- return value_.at(this->get_flat_index(ind));
- }
-
- const data<T, encode::Native>& at(const std::array<std::size_t, sizeof...(D)>& 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...}));
- }
-
- template<std::size_t i>
- std::size_t get_dim_size() const {
- return parameter_pack_value<i, std::size_t, D...>::value;
- }
-private:
- std::size_t get_flat_index(const std::array<std::size_t, sizeof...(D)>& i) const {
- std::size_t s = 0;
-
- std::size_t stride = 1;
-
- constexpr static std::array<std::size_t, sizeof...(D)> dims_{D...};
-
- for(std::size_t iter = 0; iter < sizeof...(D); ++iter){
- assert(i.at(iter) < dims_.at(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/c++/codec/forst.h b/c++/codec/forst.h
deleted file mode 100644
index 7e8fbf0..0000000
--- a/c++/codec/forst.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include "data.h"
-
-namespace saw {
-namespace encode {
-struct KelForst {};
-}
-}
-
-#include "forst.tmpl.hpp"
-
-namespace saw {
-class data<schema::String, encode::KelForst> {
-private:
- own<buffer> buff_;
-public:
- data(own<buffer> buff):
- buff_{std::move(buff)}
- {}
-};
-
-template<typename... T, string_literal... Keys>
-class data<schema::Struct<schema::Member<T,Keys>...>, encode::KelForst> {
-private:
- own<buffer> buff_;
-public:
- data(own<buffer> buff):
- buff_{std::move(buff)}
- {}
-};
-}
diff --git a/c++/codec/forst.tmpl.h b/c++/codec/forst.tmpl.h
deleted file mode 100644
index 30d18ef..0000000
--- a/c++/codec/forst.tmpl.h
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace saw {
-namespace impl {
-struct forst_decode {
-
-};
-}
-}
diff --git a/c++/codec/interface.h b/c++/codec/interface.h
deleted file mode 100644
index b1422a9..0000000
--- a/c++/codec/interface.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#pragma once
-
-#include <forstio/core/error.h>
-#include "schema.h"
-#include "data.h"
-
-namespace saw {
-template<typename SchemaFunc, typename Encode, typename Func>
-class function;
-
-template<typename Request, typename Response, typename Encode, typename Func>
-class function<schema::Function<Request, Response>, Encode, Func> {
-private:
- Func func_;
-public:
- function(Func func):
- func_{std::move(func)}
- {}
-
- error_or<data<Response, Encode>> call(data<Request, Encode> req){
- return func_(std::move(req));
- }
-};
-
-template<typename T, typename Encode, typename... Funcs>
-class interface;
-
-template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename... Funcs>
-class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Funcs...> {
-private:
- std::tuple<function<schema::Function<Requests, Responses>, Encode, Funcs>...> funcs_;
-public:
- interface(function<schema::Function<Requests, Responses>, Encode, Funcs>... funcs):
- funcs_{std::move(funcs)...}
- {}
-
- /**
- * Get the function based on the string literal matching the position in the tuple
- */
- template<string_literal Lit>
- function<
- schema::Function<
- typename parameter_pack_type<
- parameter_key_pack_index<
- Lit, Names...
- >::value
- , Requests...>::type
- ,
- typename parameter_pack_type<
- parameter_key_pack_index<
- Lit, Names...
- >::value
- , Responses...>::type
- >
- ,
- Encode
- ,
- typename parameter_pack_type<
- parameter_key_pack_index<
- Lit, Names...
- >::value
- , Funcs...>::type
- >& get(){
- return std::get<parameter_key_pack_index<Lit, Names...>::value>(funcs_);
- }
-
- template<string_literal Lit>
- error_or<data<
- typename parameter_pack_type<
- parameter_key_pack_index<
- Lit, Names...
- >::value
- , Responses...>::type
- , Encode>> call(
- data<
- typename parameter_pack_type<
- parameter_key_pack_index<
- Lit, Names...
- >::value
- , Requests...>::type
- , Encode> req
- ){
- return get<Lit>().call(std::move(req));
- }
-
-};
-
-template<typename T, typename Encode>
-struct function_factory {
- template<typename Func>
- static function<T,Encode, Func> create(Func func){
- return function<T,Encode,Func>{std::move(func)};
- }
-};
-
-template<typename T, typename Encode>
-struct interface_factory {
- template<typename... Func>
- static interface<T,Encode, Func...> create(Func... func){
- return interface<T,Encode, Func...>{std::move(func)...};
- }
-};
-}
diff --git a/c++/codec/rpc.h b/c++/codec/rpc.h
deleted file mode 100644
index b21ecf8..0000000
--- a/c++/codec/rpc.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-namespace saw {
-template<typename T>
-class remote {
- static_assert(always_false<T>, "Type of remote not supported");
-};
-
-template<typename T>
-class rpc_client {
- template<typename... T>
- struct request {
- private:
- std::tuple<id<T>> ids_;
- public:
- error_or<data<T>> wait();
- };
-
- template<typename... T>
- request<T...> request_data(id<T>... data);
-};
-
-template<typename T>
-class rpc_server {
-};
-}
diff --git a/c++/codec/schema.h b/c++/codec/schema.h
deleted file mode 100644
index a8494fe..0000000
--- a/c++/codec/schema.h
+++ /dev/null
@@ -1,109 +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
- * For example we can transport any base64 encodings in JSON
- *
- * using WrappedExample = schema::Tuple<
- * schema::Wrapper<schema::String, encode::Base64>
- * >;
- *
- * data<WrappedExample, encode::Json> ex_data;
- */
-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 allowing to distinguish Ints from VarInts
- */
-template<typename T, std::size_t MaxLen>
-struct VariableLengthPrimitive {};
-
-using VarInt = VariableLengthPrimitive<SignedInteger, 5>;
-using VarLong = VariableLengthPrimitive<SignedInteger, 10>;
-
-/**
- * Classes enabling Rpc calls
- */
-template <class Request, class Response>
-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... Requests, class... Responses, string_literal... Names>
-struct Interface<Member<Function<Requests, Responses>,Names>...> {};
-
-// NOLINTEND
-} // namespace schema
-} // namespace saw
diff --git a/c++/codec/schema_hash.h b/c++/codec/schema_hash.h
deleted file mode 100644
index 5690166..0000000
--- a/c++/codec/schema_hash.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#pragma once
-
-#include "schema.h"
-
-namespace saw {
-struct schema_hash_combine {
- static constexpr uint64_t apply(uint64_t seed, uint64_t v){
- return (seed ^ v) * 1099511628211u;
-
-
- return seed ^( std::hash<uint64_t>{}(v) + 0x9e3779b9 + (seed<<6) + (seed >> 2));
- }
-};
-
-template<typename Schema>
-struct schema_hash {
- static_assert(always_false<Schema>, "Not schema_hashable");
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::SignedInteger,1>> {
- static constexpr uint64_t base_value = 0u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::SignedInteger,2>> {
- static constexpr uint64_t base_value = 1u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::SignedInteger,4>> {
- static constexpr uint64_t base_value = 2u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::SignedInteger,8>> {
- static constexpr uint64_t base_value = 3u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::UnsignedInteger,1>> {
- static constexpr uint64_t base_value = 4u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::UnsignedInteger,2>> {
- static constexpr uint64_t base_value = 5u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::UnsignedInteger,4>> {
- static constexpr uint64_t base_value = 6u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::UnsignedInteger,8>> {
- static constexpr uint64_t base_value = 7u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::FloatingPoint,4>> {
- static constexpr uint64_t base_value = 8u;
-};
-
-template<>
-struct schema_hash<schema::Primitive<schema::FloatingPoint,8>> {
- static constexpr uint64_t base_value = 9u;
-};
-
-template<typename... T>
-struct schema_hash<schema::Tuple<T...>> {
- static constexpr uint64_t base_value = 10u;
-};
-
-template<typename... T, string_literal Literal>
-struct schema_hash<schema::Struct<schema::Member<T,Literal>...>> {
- static constexpr uint64_t base_value = 11u;
-};
-
-template<typename... T, string_literal Literal>
-struct schema_hash<schema::Union<schema::Member<T,Literal>...>> {
- static constexpr uint64_t base_value = 12u;
-};
-
-template<typename T, size_t Dim>
-struct schema_hash<schema::Array<T,Dim>> {
- static constexpr uint64_t base_value = 13u;
-};
-
-template<>
-struct schema_hash<schema::String> {
- static constexpr uint64_t base_value = 14u;
-};
-
-template<typename T, typename N>
-struct schema_hash<schema::Wrapper<T,N>> {
- static constexpr uint64_t base_value = 15u;
-};
-
-template<typename T, size_t... Dims>
-struct schema_hash<schema::FixedArray<T,Dims...>> {
- static constexpr uint64_t base_value = 16u;
-};
-
-}
diff --git a/c++/codec/schema_stringify.h b/c++/codec/schema_stringify.h
deleted file mode 100644
index a82081a..0000000
--- a/c++/codec/schema_stringify.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#pragma once
-
-#include "schema.h"
-
-#include <sstream>
-#include <type_traits>
-
-namespace saw {
-template<typename Schema>
-struct schema_stringify {
- static_assert(always_false<Schema>, "Not supported");
-};
-
-template<typename T, size_t Dim>
-struct schema_stringify<schema::Array<T,Dim>> {
- static void apply(std::stringstream& iss) {
- iss << "saw::schema::Array<";
- schema_stringify<T>::apply(iss);
- iss << ",";
- iss << ct_convert_to_digits<Dim, 10>::literal.view();
- iss << ">";
- }
-};
-
-template<typename T, size_t N>
-struct schema_stringify<schema::Primitive<T,N>> {
- static void apply(std::stringstream& iss) {
- iss << "saw::schema::Primitive<";
- schema_stringify<T>::apply(iss);
- iss << ",";
- iss << ct_convert_to_digits<N,10>::literal.view();
- iss << ">";
- }
-};
-
-template<>
-struct schema_stringify<schema::SignedInteger> {
- static void apply(std::stringstream& iss) {
- iss << "saw:schema::SignedInteger";
- }
-};
-
-template<>
-struct schema_stringify<schema::UnsignedInteger> {
- static void apply(std::stringstream& iss) {
- iss << "saw:schema::UnsignedInteger";
- }
-};
-
-template<>
-struct schema_stringify<schema::FloatingPoint> {
- static void apply(std::stringstream& iss) {
- iss << "saw:schema::FloatingPoint";
- }
-};
-
-template<typename... T>
-struct schema_stringify_member {
- static void apply(std::stringstream& iss) {
- (void)iss;
- }
-};
-
-template<typename T0, string_literal Name, typename... TL>
-struct schema_stringify_member<schema::Member<T0,Name>, TL...> {
-
- static void apply(std::stringstream& iss) {
- iss << "saw::schema::Member<";
- schema_stringify<T0>::apply(iss);
- iss << ",\"";
- iss << Name.view();
- iss << "\">";
- if constexpr ( sizeof...(TL) > 0){
- iss << ",";
- schema_stringify_member<TL...>::apply(iss);
- }
- }
-};
-
-template<typename... T, string_literal... Lits>
-struct schema_stringify<schema::Struct<schema::Member<T,Lits>...>> {
- static void apply(std::stringstream& iss) {
- iss << "saw::schema::Struct<";
- schema_stringify_member<schema::Member<T,Lits>...>::apply(iss);
- iss << ">";
- }
-};
-
-template<typename... T, string_literal... Lits>
-struct schema_stringify<schema::Union<schema::Member<T,Lits>...>> {
- static void apply(std::stringstream& iss) {
- iss << "saw::schema::Union<";
- schema_stringify_member<schema::Member<T,Lits>...>::apply(iss);
- iss << ">";
- }
-};
-
-template<typename Req, typename Resp>
-struct schema_stringify<schema::Function<Req, Resp>> {
- static void apply(std::stringstream& iss){
- iss << "saw::schema::Function<";
- schema_stringify<Req>::apply(iss);
- iss << ",";
- schema_stringify<Resp>::apply(iss);
- iss << ">";
- }
-};
-
-template<typename... T, string_literal... Lits>
-struct schema_stringify<schema::Interface<schema::Member<T,Lits>...>>{
- static void apply(std::stringstream& iss){
- iss << "saw::schema::Interface<";
- schema_stringify_member<schema::Member<T,Lits>...>::apply(iss);
- iss << ">";
- }
-};
-
-}
diff --git a/c++/codec/simple.h b/c++/codec/simple.h
deleted file mode 100644
index 8760754..0000000
--- a/c++/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/c++/codec/stream_value.h b/c++/codec/stream_value.h
deleted file mode 100644
index 09203cb..0000000
--- a/c++/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
generated by cgit v1.2.3 (git 2.25.1) at 2025-09-17 22:22:39 +0000