From 8dad985328e2183b224300aa992951131956fdb3 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Tue, 23 Jan 2024 13:12:11 +0100
Subject: 
 core,codec-json,codec-minecraft,codec-netcdf,codec,io-tls,io,io_codec,window,window-opengl:
 Renamed file endings and changed includes

---
 modules/codec/c++/simple.h | 389 ---------------------------------------------
 1 file changed, 389 deletions(-)
 delete mode 100644 modules/codec/c++/simple.h

(limited to 'modules/codec/c++/simple.h')

diff --git a/modules/codec/c++/simple.h b/modules/codec/c++/simple.h
deleted file mode 100644
index aff0626..0000000
--- a/modules/codec/c++/simple.h
+++ /dev/null
@@ -1,389 +0,0 @@
-#pragma once
-
-#include "data.h"
-#include "stream_value.h"
-
-#include <forstio/buffer.h>
-#include <forstio/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;
-	}
-};
-}
-- 
cgit v1.2.3