From 2e5932edbda07d5b142df95cfe79268ea7fb997b Mon Sep 17 00:00:00 2001
From: Claudius Holeksa <mail@keldu.de>
Date: Wed, 3 May 2023 19:06:22 +0200
Subject: changing approach to storage

---
 forstio/codec/data.h              |  89 ++++++
 forstio/codec/message.h           | 564 --------------------------------------
 forstio/codec/message_container.h | 246 -----------------
 forstio/codec/proto_kel.h         |  41 +++
 4 files changed, 130 insertions(+), 810 deletions(-)
 create mode 100644 forstio/codec/data.h
 delete mode 100644 forstio/codec/message.h
 delete mode 100644 forstio/codec/message_container.h
 create mode 100644 forstio/codec/proto_kel.h

(limited to 'forstio/codec')

diff --git a/forstio/codec/data.h b/forstio/codec/data.h
new file mode 100644
index 0000000..1682ae7
--- /dev/null
+++ b/forstio/codec/data.h
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <forstio/core/common.h>
+#include "schema.h"
+
+namespace saw {
+namespace encode {
+struct Native {};
+}
+/*
+ * 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<typename T, typename Encoding = encode::Native>
+class data {
+private:
+	static_assert(always_false<T>, "Type not supported");
+};
+
+template<>
+class data<schema::String, encode::Native> {
+private:
+	std::string value_;
+public:
+	SAW_FORBID_COPY(data);
+
+	data(std::string&& value__):value_{std::move(value__)}{}
+
+	std::size_t size() const {
+		return value_.size();
+	}
+
+	bool operator==(const data<schema::String, encode::Native>& data){
+		return value_ == data.value_;
+	}
+};
+
+template<typename T, size_t N>
+class data<schema::Primitive<T,N>, encode::Native> {
+private:
+};
+}
diff --git a/forstio/codec/message.h b/forstio/codec/message.h
deleted file mode 100644
index f0cadfd..0000000
--- a/forstio/codec/message.h
+++ /dev/null
@@ -1,564 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <tuple>
-#include <type_traits>
-#include <variant>
-#include <vector>
-
-#include <cassert>
-
-#include <forstio/common.h>
-#include <forstio/string_literal.h>
-
-#include "message_container.h"
-#include "schema.h"
-
-namespace saw {
-class message_base {
-protected:
-	bool set_explicitly_ = false;
-
-public:
-	template <class T> T &as() {
-		static_assert(std::is_base_of<message_base, T>());
-		return dynamic_cast<T &>(*this);
-	}
-
-	template <class T> const T &as() const {
-		static_assert(std::is_base_of<message_base, T>());
-		return dynamic_cast<const T &>(*this);
-	}
-};
-/*
- * Representing all message types
- * Description which type to use happens through the use of the schema classes
- * in schema.h The message classes are wrapper classes which store the data
- * according to the specified container class.
- *
- * The reader and builder classe exist to create some clarity while implementing
- * parsers. Also minor guarantess are provided if the message is used as a
- * template parameter.
- */
-
-/*
- * Struct Message
- */
-template <class... V, string_literal... Keys, class Container>
-class message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
-	: public message_base {
-private:
-	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
-	using MessageType = message<SchemaType, Container>;
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same the schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-	private:
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg) : message_{msg} {}
-
-		reader as_reader() { return reader{message_}; }
-
-		/*
-		 * Initialize a member by index
-		 */
-		template <size_t i>
-		typename std::enable_if<
-			!schema_is_array<
-				typename message_parameter_pack_type<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-		init() {
-			return typename Container::template ElementType<i>::builder{
-				message_.container_.template get<i>()};
-		}
-
-		/*
-		 * Initialize a member by their name
-		 * This is the preferred method for schema::Struct messages
-		 */
-		template <string_literal Literal>
-		typename std::enable_if<
-			!schema_is_array<typename message_parameter_pack_type<
-				message_parameter_key_pack_index<Literal, Keys...>::Value,
-				V...>::Type>::Value,
-			typename Container::template ElementType<
-				message_parameter_key_pack_index<Literal, Keys...>::Value>::
-				builder>::type
-		init() {
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return init<i>();
-		}
-
-		template <size_t i>
-		typename std::enable_if<
-			schema_is_array<
-				typename message_parameter_pack_type<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-		init(size_t size = 0) {
-			auto array_builder =
-				typename Container::template ElementType<i>::builder{
-					message_.container_.template get<i>(), size};
-			return array_builder;
-		}
-
-		/*
-		 * Version for array schema type
-		 */
-		template <string_literal Literal>
-		typename std::enable_if<
-			schema_is_array<typename message_parameter_pack_type<
-				message_parameter_key_pack_index<Literal, Keys...>::Value,
-				V...>::Type>::Value,
-			typename Container::template ElementType<
-				message_parameter_key_pack_index<Literal, Keys...>::Value>::
-				builder>::type
-		init(size_t size) {
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return init<i>(size);
-		}
-	};
-
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(MessageType &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_}; }
-
-		/*
-		 * Get member by index
-		 */
-		template <size_t i>
-		typename Container::template ElementType<i>::reader get() {
-			return typename Container::template ElementType<i>::reader{
-				message_.container_.template get<i>()};
-		}
-
-		/*
-		 * Get member by name
-		 * This is the preferred method for schema::Struct messages
-		 */
-		template <string_literal Literal>
-		typename Container::template ElementType<
-			message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
-		get() {
-			// The index of the first match
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return get<i>();
-		}
-	};
-
-	builder build() { return builder{*this}; }
-
-	reader read() { return reader{*this}; }
-};
-
-/*
- * Union message class. Wrapper object
- */
-template <class... V, string_literal... Keys, class Container>
-class message<schema::Union<schema::NamedMember<V, Keys>...>, Container> final
-	: public message_base {
-private:
-	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
-	using MessageType = message<SchemaType, Container>;
-
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same the schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-	private:
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg) : message_{msg} {}
-
-		reader as_reader() { return reader{message_}; }
-
-		template <size_t i>
-		typename std::enable_if<
-			!schema_is_array<
-				typename message_parameter_pack_type<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-
-		init() {
-			return typename Container::template ElementType<i>::builder{
-				message_.container_.template get<i>()};
-		}
-
-		template <string_literal Literal>
-		typename std::enable_if<
-			!schema_is_array<typename message_parameter_pack_type<
-				message_parameter_key_pack_index<Literal, Keys...>::Value,
-				V...>::Type>::Value,
-			typename Container::template ElementType<
-				message_parameter_key_pack_index<Literal, Keys...>::Value>::
-				builder>::type
-		init() {
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return init<i>();
-		}
-
-		/*
-		 * If Schema is Array
-		 */
-		template <size_t i>
-		typename std::enable_if<
-			schema_is_array<
-				typename message_parameter_pack_type<i, V...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-		init(size_t size = 0) {
-			return typename Container::template ElementType<i>::builder{
-				message_.container_.template get<i>(), size};
-		}
-
-		template <string_literal Literal>
-		typename std::enable_if<
-			schema_is_array<typename message_parameter_pack_type<
-				message_parameter_key_pack_index<Literal, Keys...>::Value,
-				V...>::Type>::Value,
-			typename Container::template ElementType<
-				message_parameter_key_pack_index<Literal, Keys...>::Value>::
-				builder>::type
-		init(size_t size) {
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return init<i>(size);
-		}
-	};
-
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(MessageType &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_}; }
-
-		template <size_t i>
-		typename Container::template ElementType<i>::reader get() {
-			return typename Container::template ElementType<i>::reader{
-				message_.container_.template get<i>()};
-		}
-
-		template <string_literal Literal>
-		typename Container::template ElementType<
-			message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
-		get() {
-			// The index of the first match
-			constexpr size_t i =
-				message_parameter_key_pack_index<Literal, Keys...>::Value;
-
-			return get<i>();
-		}
-
-		template <string_literal Literal>
-		static constexpr size_t to_index() noexcept {
-			return message_parameter_key_pack_index<Literal, Keys...>::Value;
-		}
-
-		size_t index() const noexcept { return message_.container_.index(); }
-
-		template <string_literal Literal> bool has_alternative() const {
-			return index() == to_index<Literal>();
-		}
-	};
-};
-
-/*
- * Array message class. Wrapper around an array schema element
- */
-template <class T, class Container>
-class message<schema::Array<T>, Container> final : public message_base {
-private:
-	using SchemaType = schema::Array<T>;
-	using MessageType = message<SchemaType, Container>;
-
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same Schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-	private:
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg, size_t size) : message_{msg} {
-			if (size > 0) {
-				message_.container_.resize(size);
-			}
-		}
-
-		reader as_reader() { return reader{message_}; }
-
-		typename Container::ElementType::builder init(size_t i) {
-			return typename Container::ElementType::builder{
-				message_.container_.get(i)};
-		}
-
-		size_t size() const { return message_.container_.size(); }
-
-		void resize(size_t size) { message_.container_.resize(size); }
-	};
-
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(MessageType &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_, 0}; }
-
-		typename Container::ElementType::reader get(size_t i) {
-			return typename Container::ElementType::reader{
-				message_.container_.get(i)};
-		}
-
-		size_t size() const { return message_.container_.size(); }
-	};
-};
-
-/*
- * Tuple message class. Wrapper around a tuple schema
- */
-template <class... T, class Container>
-class message<schema::Tuple<T...>, Container> final : public message_base {
-private:
-	using SchemaType = schema::Tuple<T...>;
-	using MessageType = message<SchemaType, Container>;
-
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same the schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg) : message_{msg} {}
-
-		reader as_reader() { return reader{message_}; }
-
-		template <size_t i>
-		typename std::enable_if<
-			!schema_is_array<
-				typename message_parameter_pack_type<i, T...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-		init() {
-			return typename Container::template ElementType<i>::builder{
-				message_.container_.template get<i>()};
-		}
-
-		template <size_t i>
-		typename std::enable_if<
-			schema_is_array<
-				typename message_parameter_pack_type<i, T...>::Type>::Value,
-			typename Container::template ElementType<i>::builder>::type
-		init(size_t size = 0) {
-			return typename Container::template ElementType<i>::builder{
-				message_.container_.template get<i>(), size};
-		}
-	};
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(MessageType &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_}; }
-
-		template <size_t i>
-		typename Container::template ElementType<i>::reader get() {
-			return typename Container::template ElementType<i>::reader{
-				message_.container_.template get<i>()};
-		}
-	};
-};
-
-/*
- * Primitive type (float, double, uint8_t, uint16_t, uint32_t, uint64_t, int8_t,
- * int16_t, int32_t, int64_t) message class
- */
-template <class T, size_t N, class Container>
-class message<schema::Primitive<T, N>, Container> final : public message_base {
-private:
-	using SchemaType = schema::Primitive<T, N>;
-	using MessageType = message<SchemaType, Container>;
-
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same the schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-	private:
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg) : message_{msg} {}
-
-		reader as_reader() { return reader{message_}; }
-
-		void set(const typename Container::ValueType &value) {
-			message_.container_.set(value);
-		}
-	};
-
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(message &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_}; }
-
-		const typename Container::ValueType &get() const {
-			return message_.container_.get();
-		}
-	};
-};
-
-template <class Container>
-class message<schema::String, Container> final : public message_base {
-private:
-	using SchemaType = schema::String;
-	using MessageType = message<SchemaType, Container>;
-
-	Container container_;
-
-	static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
-				  "Container should have same the schema as Message");
-
-	friend class builder;
-	friend class reader;
-
-public:
-	class reader;
-	class builder {
-	private:
-		MessageType &message_;
-
-	public:
-		builder(MessageType &msg) : message_{msg} {}
-
-		reader as_reader() { return reader{message_}; }
-
-		void set(std::string &&str) { message_.container_.set(std::move(str)); }
-		void set(const std::string_view str) { message_.container_.set(str); }
-		void set(const char *str) { set(std::string_view{str}); }
-	};
-
-	class reader {
-	private:
-		MessageType &message_;
-
-	public:
-		reader(MessageType &msg) : message_{msg} {}
-
-		builder as_builder() { return builder{message_}; }
-
-		const std::string_view get() const { return message_.container_.get(); }
-	};
-};
-
-template <class Schema, class Container = message_container<Schema>>
-class heap_message_root {
-private:
-	own<message<Schema, Container>> root_;
-
-public:
-	heap_message_root(own<message<Schema, Container>> r)
-		: root_{std::move(r)} {}
-
-	typename message<Schema, Container>::builder build() {
-		assert(root_);
-		return typename message<Schema, Container>::builder{*root_};
-	}
-
-	typename message<Schema, Container>::reader read() {
-		assert(root_);
-		return typename message<Schema, Container>::reader{*root_};
-	}
-};
-
-template <class T, class Container>
-class heap_message_root<schema::Array<T>, Container> {
-public:
-	using Schema = schema::Array<T>;
-
-private:
-	own<message<Schema, Container>> root_;
-
-public:
-	heap_message_root(own<message<Schema, Container>> r)
-		: root_{std::move(r)} {}
-
-	typename message<Schema, Container>::builder build(size_t size) {
-		assert(root_);
-		return typename message<Schema, Container>::builder{*root_, size};
-	}
-
-	typename message<Schema, Container>::reader read() {
-		assert(root_);
-		return typename message<Schema, Container>::reader{*root_};
-	}
-};
-
-/*
- * Minor helper for creating a message root
- */
-template <class Schema, class Container = message_container<Schema>>
-inline heap_message_root<Schema, Container> new_heap_message_root() {
-	own<message<Schema, Container>> root = heap<message<Schema, Container>>();
-	return heap_message_root<Schema, Container>{std::move(root)};
-}
-} // namespace saw
diff --git a/forstio/codec/message_container.h b/forstio/codec/message_container.h
deleted file mode 100644
index 191052a..0000000
--- a/forstio/codec/message_container.h
+++ /dev/null
@@ -1,246 +0,0 @@
-#pragma once
-
-#include "schema.h"
-
-#include <variant>
-#include <vector>
-
-namespace saw {
-template <class T> class message_container;
-
-template <class T, class Container = message_container<T>> class message;
-
-template <size_t N, class... T> struct message_parameter_pack_type;
-
-template <class TN, class... T>
-struct message_parameter_pack_type<0, TN, T...> {
-	using Type = TN;
-};
-
-template <size_t N, class TN, class... T>
-struct message_parameter_pack_type<N, TN, T...> {
-	static_assert(sizeof...(T) > 0, "Exhausted parameters");
-	using Type = typename message_parameter_pack_type<N - 1, T...>::Type;
-};
-
-template <class T, class... TL> struct MessageParameterPackIndex;
-
-template <class T, class... TL> struct MessageParameterPackIndex<T, T, TL...> {
-	static constexpr size_t Value = 0u;
-};
-
-template <class T, class TL0, class... TL>
-struct MessageParameterPackIndex<T, TL0, TL...> {
-	static constexpr size_t Value =
-		1u + MessageParameterPackIndex<T, TL...>::Value;
-};
-
-/*
- * Nightmare inducing compiler problems found here. Somehow non-type
- * StringLiterals cannot be resolved as non-type primitive template values can.
- * This is the workaround
- */
-template <string_literal V, string_literal Key0, string_literal... Keys>
-struct message_parameter_key_pack_index_helper {
-	static constexpr size_t Value =
-		(V == Key0)
-			? (0u)
-			: (1u + message_parameter_key_pack_index_helper<V, Keys...>::Value);
-};
-
-template <string_literal V, string_literal Key0>
-struct message_parameter_key_pack_index_helper<V, Key0> {
-	static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
-};
-
-template <string_literal V, string_literal... Keys>
-struct message_parameter_key_pack_index {
-	static constexpr size_t Value =
-		message_parameter_key_pack_index_helper<V, Keys...>::Value;
-	static_assert(Value < sizeof...(Keys),
-				  "Provided StringLiteral doesn't exist in searched list");
-};
-
-template <class T> struct schema_is_array {
-	constexpr static bool Value = false;
-};
-
-template <class T> struct schema_is_array<schema::Array<T>> {
-	constexpr static bool Value = true;
-};
-
-template <class... V, string_literal... Keys>
-class message_container<schema::Struct<schema::NamedMember<V, Keys>...>> {
-private:
-	using ValueType = std::tuple<message<V, message_container<V>>...>;
-	ValueType values_;
-
-public:
-	using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
-
-	template <size_t i>
-	using ElementType = typename message_parameter_pack_type<
-		i, message<V, message_container<V>>...>::Type;
-
-	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
-};
-
-/*
- * Union storage
- */
-template <class... V, string_literal... Keys>
-class message_container<schema::Union<schema::NamedMember<V, Keys>...>> {
-private:
-	using ValueType = std::variant<message<V, message_container<V>>...>;
-	ValueType value_;
-
-public:
-	using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
-
-	template <size_t i>
-	using ElementType = typename message_parameter_pack_type<
-		i, message<V, message_container<V>>...>::Type;
-
-	template <size_t i> ElementType<i> &get() {
-		if (i != value_.index()) {
-			using MessageIV =
-				typename message_parameter_pack_type<i, V...>::Type;
-			value_ = message<MessageIV, message_container<MessageIV>>{};
-		}
-		return std::get<i>(value_);
-	}
-
-	size_t index() const noexcept { return value_.index(); }
-};
-
-/*
- * Array storage
- */
-
-template <class T> class message_container<schema::Array<T>> {
-private:
-	using ValueType = std::vector<message<T, message_container<T>>>;
-	ValueType values_;
-
-public:
-	using SchemaType = schema::Array<T>;
-
-	using ElementType = message<T, message_container<T>>;
-
-	message<T, message_container<T>> &get(size_t index) {
-		return values_.at(index);
-	}
-
-	void resize(size_t size) { values_.resize(size); }
-
-	size_t size() const { return values_.size(); }
-};
-
-/*
- * Tuple storage
- */
-template <class... T> class message_container<schema::Tuple<T...>> {
-private:
-	using ValueType = std::tuple<message<T, message_container<T>>...>;
-	ValueType values_;
-
-public:
-	using SchemaType = schema::Tuple<T...>;
-
-	template <size_t i>
-	using ElementType = typename message_parameter_pack_type<
-		i, message<T, message_container<T>>...>::Type;
-
-	template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
-};
-
-/*
- * Helper for the basic message container, so the class doesn't have to be
- * specialized 10 times.
- */
-template <class T> struct PrimitiveTypeHelper;
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 1>> {
-	using Type = int8_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 2>> {
-	using Type = int16_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 4>> {
-	using Type = int32_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::SignedInteger, 8>> {
-	using Type = int64_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 1>> {
-	using Type = uint8_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 2>> {
-	using Type = uint16_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 4>> {
-	using Type = uint32_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::UnsignedInteger, 8>> {
-	using Type = uint64_t;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 4>> {
-	using Type = float;
-};
-
-template <>
-struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 8>> {
-	using Type = double;
-};
-
-template <class T, size_t N> class message_container<schema::Primitive<T, N>> {
-public:
-	using SchemaType = schema::Primitive<T, N>;
-	using ValueType =
-		typename PrimitiveTypeHelper<schema::Primitive<T, N>>::Type;
-
-private:
-	ValueType value_;
-
-public:
-	message_container() : value_{0} {}
-
-	void set(const ValueType &v) { value_ = v; }
-
-	const ValueType &get() const { return value_; }
-};
-
-template <> class message_container<schema::String> {
-public:
-	using SchemaType = schema::String;
-	using ValueType = std::string;
-	using ValueViewType = std::string_view;
-
-private:
-	ValueType value_;
-
-public:
-	void set(ValueType &&v) { value_ = std::move(v); }
-	void set(const ValueType &v) { value_ = v; }
-	void set(const ValueViewType v) { value_ = std::string{v}; }
-
-	const ValueType &get() const { return value_; }
-};
-} // namespace saw
diff --git a/forstio/codec/proto_kel.h b/forstio/codec/proto_kel.h
new file mode 100644
index 0000000..c28f7d6
--- /dev/null
+++ b/forstio/codec/proto_kel.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "data.h"
+
+#include <forstio/core/error.h>
+
+namespace saw {
+namespace encode {
+struct ProtoKel {};
+}
+
+template<typename Schema>
+class data<Schema, encode::ProtoKel> {
+private:
+	own<buffer> buffer_;
+public:
+	data(own<buffer>&& buffer__):buffer_{std::move(buffer__)}{}
+
+	buffer& get_buffer(){
+		return *buffer_;
+	}
+
+	const buffer& get_buffer() const {
+		return *buffer_;
+	}
+};
+
+template<typename Schema>
+class codec<Schema, encode::ProtoKel> {
+private:
+public:
+	error_or<data<Schema, encode::Native>> decode(const data<Schema, encode::ProtoKel>& encoded){
+		return make_error<err::critical>();
+	}
+
+	error_or<data<Schema, encode::ProtoKel>> encode(const data<Schema, encode::Native>& native){
+		return make_error<err::critical>();
+	}
+};
+}
+}
-- 
cgit v1.2.3