From 6ca91987ec91621577468ebf68fd68fc5433284a Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Sun, 21 Jul 2024 22:23:59 +0200
Subject: wip

---
 modules/codec/c++/data.hpp        | 105 +++++++++++++++++++++++++++++++++++++-
 modules/codec/c++/schema_meta.hpp |  68 ++++++++++++++++++++++++
 2 files changed, 172 insertions(+), 1 deletion(-)
 create mode 100644 modules/codec/c++/schema_meta.hpp

(limited to 'modules/codec/c++')

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index b3e4fe2..b1e9401 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "schema.hpp"
+#include "schema_meta.hpp"
 
 namespace saw {
 namespace storage {
@@ -83,17 +84,26 @@ struct native_data_type<schema::Primitive<schema::FloatingPoint, 8>> {
 template<typename T, typename Encoding = encode::Native, typename Storage = storage::Default>
 class data {
 private:
-	static_assert(always_false<T>, "Type not supported");
+	static_assert(always_false<T>, "Type not supported.");
+};
+
+template<>
+class data<schema::Void> {
+public:
+	using Schema = schema::Void;
+	using MetaSchema = schema::Void;
 };
 
 template<typename T, size_t N, typename Storage>
 class data<schema::Primitive<T,N>, encode::Native, Storage> {
 public:
 	using Schema = schema::Primitive<T,N>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	typename native_data_type<Schema>::type value_;
 public:
 	data():value_{}{}
+	data(data<MetaSchema, encode::Native>):value_{}{}
 
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
@@ -160,10 +170,12 @@ template<typename TA, uint64_t NA, typename TB, uint64_t NB, typename Storage>
 class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native, Storage>{
 public:
 	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	data<typename Schema::StorageSchema, encode::Native, Storage> value_;
 public:
 	data():value_{}{}
+	data(data<MetaSchema, encode::Native>):value_{}{}
 
 	data(typename saw::native_data_type<typename Schema::InterfaceSchema>::type val__):value_{static_cast<typename saw::native_data_type<typename Schema::StorageSchema>::type>(val__)}{}
 
@@ -261,10 +273,33 @@ public:
  */
 template<typename... T, string_literal... literals>
 class data<schema::Union<schema::Member<T, literals>...>, encode::Native, storage::Default> {
+public:
+	using Schema = schema::Union<schema::Member<T,literals>...>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	std::variant<data<T,encode::Native, storage::Default>...> value_;
+	
+	template<uint64_t i = 0u>
+	struct init_helper {
+		static void apply(std::variant<data<T,encode::Native,storage::Default>...>& val, data<MetaSchema, encode::Native>&& init){
+			if( init.index() == i ){
+				auto& val_i = val.template init<i>();
+				val_i = {std::move(init.template get<i>())};
+				return;
+			}
+
+			if constexpr ( (i+1u) < sizeof...(T) ){
+				init_helper<i+1u>::apply(val, init);
+			}
+		}
+	};
 public:
 	data() = default;
+	data(data<MetaSchema, encode::Native> init){
+		if constexpr ( 0u < sizeof...(T) ){
+			init_helper<0u>::apply(value_, std::move(init));
+		}
+	}
 
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
@@ -301,16 +336,39 @@ public:
  */
 template<typename... T, string_literal... literals>
 class data<schema::Struct<schema::Member<T, literals>...>, encode::Native, storage::Default> {
+public:
+	using Schema = schema::Struct<schema::Member<T,literals>...>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	/**
 	 * Tuple storing the member values.
 	 */
 	std::tuple<data<T,encode::Native, storage::Default>...> value_;
+	
+	template<uint64_t i = 0u>
+	struct init_helper {
+		static void apply(std::tuple<data<T,encode::Native,storage::Default>...>& val, data<Schema, encode::Native>&& init){
+			auto& val_i = val.template get<i>();
+			auto& init_i = init.template get<i>();
+
+			val_i = {std::move(init_i)};
+
+			if constexpr ( (i+1u) < sizeof...(T) ){
+				init_helper<i+1u>::apply(val, init);
+			}
+		}
+	};
 public:
 	/**
 	 * Default constructor.
 	 */
 	data() = default;
+	data(data<MetaSchema, encode::Native> init){
+		if constexpr ( 0u < sizeof...(T) ){
+			init_helper<0u>::apply(value_, std::move(init));
+		}
+	}
+
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
 	
@@ -352,10 +410,33 @@ public:
 
 template<typename... T>
 class data<schema::Tuple<T...>, encode::Native, storage::Default> {
+public:
+	using Schema = schema::Tuple<T...>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	std::tuple<data<T,encode::Native, storage::Default>...> value_;
+
+	template<uint64_t i = 0u>
+	struct init_helper {
+		static void apply(std::tuple<data<T,encode::Native,storage::Default>...>& val, data<MetaSchema, encode::Native>&& init){
+			auto& val_i = val.template get<i>();
+			auto& init_i = init.template get<i>();
+
+			val_i = {std::move(init_i)};
+
+			if constexpr ( (i+1u) < sizeof...(T) ){
+				init_helper<i+1u>::apply(val, init);
+			}
+		}
+	};
 public:
 	data() = default;
+	data(data<MetaSchema, encode::Native> init){
+		if constexpr ( 0u < sizeof...(T) ){
+			init_helper<0u>::apply(value_, std::move(init));
+		}
+	}
+
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
 	
@@ -376,6 +457,9 @@ public:
 
 template<typename T, size_t Dim>
 class data<schema::Array<T,Dim>, encode::Native, storage::Default> {
+	public:
+		using Schema = schema::Array<T,Dim>;
+		using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 	private:
 		// data<schema::FixedArray<schema::UInt64, Dim>> dims_;
 		std::array<uint64_t, Dim> dims_;
@@ -410,6 +494,15 @@ class data<schema::Array<T,Dim>, encode::Native, storage::Default> {
 			value_.resize(get_full_size());
 		}
 
+		data(data<MetaSchema, encode::Native> init)
+		{
+			for(uint64_t i = 0; i < Dim; ++i){
+				dims_.at(i) = init.at(i).get();
+			}
+			value_.resize(get_full_size());
+		}
+
+
 		template<size_t i = 0>
 		error_or<void> add(saw::data<T,encode::Native, storage::Default> data){
 			/** @todo
@@ -517,6 +610,9 @@ private:
 
 template<typename T, uint64_t... D>
 class data<schema::FixedArray<T,D...>, encode::Native, storage::Default> {
+public:
+	using Schema = schema::FixedArray<T,D...>;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	//using inner_type = std::array<data<T, encode::Native, storage::Default>, multiply_helper<Dims...>::value>;
 	//std::unique_ptr<inner_type> value_;
@@ -525,6 +621,7 @@ private:
 	
 public:
 	data() = default;
+	data(data<MetaSchema, encode::Native>){}
 
 	data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, sizeof...(D)>& ind){
 		return value_.at(this->get_flat_index(ind));
@@ -583,6 +680,9 @@ private:
  */
 template<>
 class data<schema::String, encode::Native, storage::Default> {
+public:
+	using Schema = schema::String;
+	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
 	/**
 	 * The native way to represent strings.
@@ -593,6 +693,9 @@ public:
 	data(uint64_t size__){
 		value_.resize(size__);
 	}
+	data(data<MetaSchema, encode::Native> init){
+		value_.resize(init.get());
+	}
 
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
diff --git a/modules/codec/c++/schema_meta.hpp b/modules/codec/c++/schema_meta.hpp
new file mode 100644
index 0000000..a37197a
--- /dev/null
+++ b/modules/codec/c++/schema_meta.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "schema.hpp"
+
+namespace saw {
+
+template<typename Schema>
+struct meta_schema {
+	static_assert(always_false<Schema>, "Not supported Schema.");
+};
+
+template<>
+struct meta_schema<schema::Void> {
+	using Schema = schema::Void;
+	using MetaSchema = schema::Void;
+};
+
+template<typename T, uint64_t N>
+struct meta_schema<schema::Primitive<T,N>> {
+	using MetaSchema = schema::Void;
+	using Schema = schema::Primitive<T,N>;
+};
+
+template<typename TA, uint64_t NA, typename TB, uint64_t NB> 
+struct meta_schema<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB> >> {
+	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
+	using MetaSchema = schema::Void;
+};
+
+template<typename... T, string_literal... Lit>
+struct meta_schema<schema::Struct<schema::Member<T,Lit>...>> {
+	using MetaSchema = schema::Struct<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
+	using Schema = schema::Struct<schema::Member<T,Lit>...>;
+};
+
+template<typename... T, string_literal... Lit>
+struct meta_schema<schema::Union<schema::Member<T,Lit>...>> {
+	using MetaSchema = schema::Union<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
+	using Schema = schema::Union<schema::Member<T,Lit>...>;
+};
+
+template<typename... T>
+struct meta_schema<schema::Tuple<T...>> {
+	using MetaSchema = schema::Tuple<typename meta_schema<T>::MetaSchema...>;
+	using Schema = schema::Tuple<T...>;
+};
+
+template<>
+struct meta_schema<schema::String> {
+	using MetaSchema = schema::UInt64;
+	using Schema = schema::String;
+};
+
+/**
+ * Technically we also can distinguish if T is primitive.
+ */
+template<typename T, uint64_t Dim>
+struct meta_schema<schema::Array<T,Dim>> {
+	using MetaSchema = schema::FixedArray<schema::UInt64,Dim>;
+	using Schema = schema::Array<T,Dim>;
+};
+
+template<typename T, uint64_t Dim>
+struct meta_schema<schema::FixedArray<T,Dim>> {
+	using MetaSchema = schema::Void;
+	using Schema = schema::FixedArray<T,Dim>;
+};
+}
-- 
cgit v1.2.3