meta: Renamed folder containing source

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