From 2790590996da2f6a0f4d59570de62078a5ac8ae2 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Mon, 5 Feb 2024 17:39:28 +0100
Subject: tools: Move to new module structure and moving to more schema based
 generation to convert more easily to json

---
 modules/tools/c++/c_gen_iface.hpp | 271 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 271 insertions(+)
 create mode 100644 modules/tools/c++/c_gen_iface.hpp

(limited to 'modules/tools/c++/c_gen_iface.hpp')

diff --git a/modules/tools/c++/c_gen_iface.hpp b/modules/tools/c++/c_gen_iface.hpp
new file mode 100644
index 0000000..b25e5eb
--- /dev/null
+++ b/modules/tools/c++/c_gen_iface.hpp
@@ -0,0 +1,271 @@
+#include <forstio/error.hpp>
+#include <forstio/codec/data.hpp>
+#include <forstio/codec/schema.hpp>
+#include <forstio/codec/schema_stringify.hpp>
+#include <forstio/templates.hpp>
+
+#include <string>
+#include <sstream>
+#include <map>
+
+#include <iostream>
+
+namespace saw {
+
+namespace schema {
+
+using CVar = Struct<
+	Member<schema::String, "schema">,
+	Member<schema::String, "type">,
+	Member<schema::String, "name">
+>;
+
+using CStruct = Struct<
+	Member<schema::String, "schema">,
+	Member<schema::String, "name">,
+	Member<Array<CVar>, "members">
+>;
+
+using CFunction = Struct<
+	Member<schema::String, "schema">,
+	Member<schema::String, "name">,
+	Member<Array<CVar>, "params">,
+	Member<CVar, "return">
+>;
+
+using CIface = Struct<
+	Member<schema::String, "schema">,
+	Member<Array<CStruct>,"structs">,
+	Member<Array<CFunction>,"functions">
+>;
+}
+/**
+ * Type meant to provide future help if I decide to introduce more maps
+ */
+/**
+namespace schema {
+using namespace saw::schema;
+Pseudo flattened
+using Foo = Struct<
+		Member<Array<Int32>, "a">
+		Member<Array<Float32>, "b">
+>;
+
+Needs to be flattened to
+
+template<typename InnerSchema>
+using FlattenedSchemaElement = Struct<
+		Member<Array<String>, "path">,
+		Member<InnerSchema, "inner_schema">
+>;
+
+// Illegal, but doable with more lines of code
+// Just use typename... T and 
+// "T..." for
+// "Member<FlattenedSchemaElement<Ele>,Names>...>"
+// and specialize somewhere else
+template<typename... Ele, string_literal... Names>
+using FlattenedSchema = Struct<
+		Member<String, "top_schema">,
+		Member<FlattenedSchemaElement<Ele>, Names>...
+>;
+}
+ */
+template<typename T, typename Res>
+struct schema_flattener {
+		static_assert(always_false<T>, "Not supported");
+};
+
+template<typename T0, string_literal Name0, typename... T, string_literal... Names, typename Res>
+struct schema_flattener<schema::Struct<schema::Member<T0,Name0>,schema::Member<T,Names>...>, Res> {
+};
+
+/**
+ * Helper to determine if we are dealing with primitive types
+ */
+template<typename Schema>
+struct c_is_primitive {
+		static constexpr bool value = false;
+};
+
+template<typename T, size_t N>
+struct c_is_primitive<schema::Primitive<T,N>> {
+		static constexpr bool value = true;
+};
+
+template<typename Schema>
+struct c_primitive_string {
+	static_assert(always_false<Schema>, "Not supported");
+};
+
+template<>
+struct c_primitive_string<schema::Int8> {
+	static constexpr std::string_view value = "int8_t";
+};
+
+template<>
+struct c_primitive_string<schema::Int16> {
+	static constexpr std::string_view value = "int16_t";
+};
+
+template<>
+struct c_primitive_string<schema::Int32> {
+	static constexpr std::string_view value = "int32_t";
+};
+
+template<>
+struct c_primitive_string<schema::Int64> {
+	static constexpr std::string_view value = "int64_t";
+};
+
+template<>
+struct c_primitive_string<schema::UInt8> {
+	static constexpr std::string_view value = "uint8_t";
+};
+
+template<>
+struct c_primitive_string<schema::UInt16> {
+	static constexpr std::string_view value = "uint16_t";
+};
+
+template<>
+struct c_primitive_string<schema::UInt32> {
+	static constexpr std::string_view value = "uint32_t";
+};
+
+template<>
+struct c_primitive_string<schema::UInt64> {
+	static constexpr std::string_view value = "uint64_t";
+};
+
+template<>
+struct c_primitive_string<schema::Float32> {
+	static constexpr std::string_view value = "float";
+};
+
+template<>
+struct c_primitive_string<schema::Float64> {
+	static constexpr std::string_view value = "double";
+};
+
+bool c_interface_function_exists(data<schema::CIface>& state, const std::string_view& name){
+	auto& funcs = state.template get<"functions">();
+	for(uint64_t i = 0; i < funcs.size(); ++i){
+		if(funcs.at(i).get<"name">() == name){
+			return true;
+		}
+	}
+	return false;
+}
+
+template<typename Schema>
+struct c_data_translater {
+	static_assert(always_false<Schema>, "Not supported");
+};
+
+template<typename T, uint64_t N>
+struct c_data_translater<schema::Primitive<T,N>> {
+	using Schema = schema::Primitive<T,N>;
+
+	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& prim){
+		/// @TODO Check if exists in CVars already
+		try{
+			std::stringstream iss;
+			schema_stringify<Schema>::apply(iss);
+			prim.template get<"schema">().set(iss.str());
+		}catch(const std::exception&){
+			return make_error<err::out_of_memory>();
+		}
+
+		return void_t{};
+	}
+};
+
+template<typename Req, typename Ret>
+struct c_data_translater<schema::Function<Req,Ret>> {
+	using Schema = schema::Function<Req,Ret>;
+
+	static error_or<void> generate(data<schema::CIface>& state, const std::string_view& func_name){
+		if(c_interface_function_exists(state, func_name)){
+			return make_error<err::invalid_state>("Function already exists");
+		}
+
+		auto& funcs = state.template get<"functions">();
+		data<schema::CFunction> function;
+		function.template get<"name">().set(std::string{func_name});
+		
+		try{
+			std::stringstream iss;
+			schema_stringify<Schema>::apply(iss);
+			function.template get<"schema">().set(iss.str());
+		}catch(const std::exception&){
+			return make_error<err::out_of_memory>();
+		}
+
+		{
+			auto& c_var = function.template get<"return">();
+			c_var.template get<"name">().set("ret_val");
+			auto eov = c_data_translater<Ret>::generate(state, c_var);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+
+		{
+			auto eov = funcs.add(std::move(function));
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+
+		return void_t{};
+	}
+};
+
+template<typename... Funcs, string_literal... Names>
+struct c_data_translater<schema::Interface<schema::Member<Funcs,Names>...>> {
+	using Schema = schema::Interface<schema::Member<Funcs, Names>...>;
+
+	template<std::size_t i>
+	static error_or<void> generate_ele(data<schema::CIface>& state){
+		using InnerSchema = typename parameter_pack_type<i, Funcs...>::type;
+		constexpr string_literal Literal = parameter_key_pack_type<i, Names...>::literal;
+		{
+			auto eov = c_data_translater<InnerSchema>::generate(state, Literal.view());
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+
+		/**
+		 * Continue if elements remain or finish
+		 */
+		if constexpr ( (i+1) < sizeof...(Funcs) ){
+			return generate_ele<i+1>(state);
+		}
+		return void_t{};
+	}
+
+	static error_or<void> generate(data<schema::CIface>& state){
+		try{
+			std::stringstream iss;
+			schema_stringify<Schema>::apply(iss);
+			state.template get<"schema">().set(iss.str());
+		}catch(const std::exception&){
+			return make_error<err::out_of_memory>();
+		}
+		
+		if constexpr (sizeof...(Funcs) > 0){
+			return generate_ele<0>(state);
+		}
+		return void_t{};
+	}
+};
+
+template<typename Interface>
+error_or<void> generate_c_interface(data<schema::CIface>& state){
+	auto eov = c_data_translater<Interface>::generate(state);
+	return eov;
+}
+
+}
-- 
cgit v1.2.3