From b8a5458a7493de17516bdb172f6a3a208dfc5eed Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Sun, 7 Jan 2024 23:57:49 +0100
Subject: tools: Dangling changes

---
 modules/tools/cli_analyzer.hpp | 103 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 86 insertions(+), 17 deletions(-)

(limited to 'modules/tools/cli_analyzer.hpp')

diff --git a/modules/tools/cli_analyzer.hpp b/modules/tools/cli_analyzer.hpp
index 295ddf6..7f3f013 100644
--- a/modules/tools/cli_analyzer.hpp
+++ b/modules/tools/cli_analyzer.hpp
@@ -21,13 +21,19 @@ struct cli_modifier {
 	codec<Schema, encode::Json> json;
 	codec<Schema, Encoding> encoded;
 
-	error_or<void> read(data<Schema, Encoding>& enc_data, std::deque<std::string>& sch_path, std::string& json_data_str){
+	error_or<void> read(
+					std::deque<std::string>& sch_path,
+					data<Schema, Encoding>& enc_data, 
+					std::string& json_data_str
+					){
 		data<Schema, encode::Native> native;
-		{
+		if constexpr ( std::is_same_v<Encoding, encode::Native> ){
 			auto eov = encoded.decode<encode::Native>(enc_data, native);
 			if(eov.is_error()){
 				return eov;
 			}
+		}else{
+				native = enc_data;
 		}
 		{
 			data<Schema, encode::Json> json_data;
@@ -37,12 +43,18 @@ struct cli_modifier {
 			}
 
 			json_data_str = convert_to_string(json_data.get_buffer());
+
+			std::cout<<json_data_str<<std::endl;
 		}
 
 		return void_t{};
 	}
 	
-	error_or<void> write(data<Schema, Encoding>& enc_data, std::deque<std::string>& sch_path, std::string& json_data_str){
+	error_or<void> write(
+					std::deque<std::string>& sch_path,
+					data<Schema, Encoding>& enc_data,
+					std::string& json_data_str
+					){
 		data<Schema, encode::Native> native;
 		{
 			/// @todo string to data
@@ -52,35 +64,85 @@ struct cli_modifier {
 				return eov;
 			}
 		}
-		{
+		if constexpr (std::is_same_v<Encoding, encode::Native> ){
 			auto eov = encoded.encode<encode::Native>(native, enc_data);
 			if(eov.is_error()){
 				return eov;
 			}
-		}i
+		}else{
+				enc_data = native;
+		}
 
 		return void_t{};
-
 	}
 };
 
+template<typename... T, typename Encoding>
+struct cli_traverser<schema::Tuple<T...>, Encoding> {
+		using Schema = schema::Tuple<T...>;
+
+		template<typename Traversal, size_t i>
+		static error_or<void> traverse_member(std::deque<std::string>& sch_path, data<Schema, Encoding>& enc_data, std::string& json_data){
+				using Type = typename parameter_pack_type<i,T...>::type;
+
+				std::string num_str = std::to_string(i);
+				if( num_str == sch_path.front() ){
+						sch_path.pop_front();
+						return cli_traverser<Type, Encoding>::traverse<Traversal>(sch_path, enc_data.template get<i>(), json_data);
+				}
+
+				if ( (i+1) < sizeof...(T)){
+						return traverse_member<Traversal, i+1>(sch_path, enc_data, json_data);
+				}
+			return make_error<err::invalid_state>("Didn't find tuple path element");
+		}
+};
+
+/**
+ * Traverse the path until we hit the end of the provided path
+ */
 template<typename... T, string_literal... Lits, typename Encoding>
 struct cli_traverser<schema::Struct<schema::Member<T,Lits>...>, Encoding> {
 	using Schema = schema::Struct<schema::Member<T,Lits>...>;
 
+	template<typename Traversal, size_t i>
+    static error_or<void> traverse_member(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
+			using Type = typename parameter_pack_type<i,T...>::type;
+		    constexpr string_literal Literal = parameter_key_pack_type<i, Lits...>::literal;
+
+			if ( Literal.view() == sch_path.front() ){
+				sch_path.pop_front();
+				return cli_traverser<Type>::traverse<Traversal>(sch_path, enc_data.template get<Literal>(), json_data);
+			}
+
+			if constexpr ( (i+1) < sizeof...(T) ) {
+				return traverse_member<Traversal, i+1>(sch_path, enc_data, json_data);
+			}
+			return make_error<err::invalid_state>("Didn't find struct path element");
+	}
+
 	template<typename Traversal>
-	static error_or<void> traverse(std::deque<std::string>& sch_path, std::string& json_data){
+	static error_or<void> traverse(std::deque<std::string>& sch_path, data<Schema,Encoding>& enc_data, std::string& json_data){
+		/**
+		 * If our path is empty, then we have reached the desired destination.
+		 */
 		if(sch_path.empty()){
+		    /**
+			 * Decide during this step if we are reading or not
+			 */
 			cli_modifier<Schema, Encoding> mod;
 			if constexpr (std::is_same_v<Traversal, cli_mode::read>){
 				return mod.read(sch_path, json_data);
 			} else if constexpr (std::is_same_v<Traversal, cli_mode::write>) {
 				return mod.write(sch_path, json_data);
 			} else {
-				return make_error<err::invalid_state>();
+				return make_error<err::invalid_state>("We only support cli_mode::read and cli_mode::write");
 			}
 		} else {
-
+				if constexpr ( sizeof...(T) > 0 ){
+						return traverse_member<Traversal, 0>(sch_path, json_data);
+				}
+				return make_error<err::invalid_state>("No elements in struct while path isn't empty");
 		}
 
 		return void_t{};
@@ -88,22 +150,29 @@ struct cli_traverser<schema::Struct<schema::Member<T,Lits>...>, Encoding> {
 };
 }
 
-template<typename Schema, typename Encoding>
-int modify_data_on_cli(int argc, char** argv){
+struct parsed_args {
+		bool read_mode = true;
+		std::string file_path;
+		std::deque<std::string> sch_path;
+};
 
-	/// @todo parse cli data
-	bool read_mode = true;
+template<typename Schema, typename Encoding>
+int modify_data_on_cli(bool read_mode, const std::string& file_path, std::deque<std::string> sch_path, std::string& json_data){
+    /**
+	 * Read data from file
+	 */
+	
 
-	std::deque<std::string> sch_path;
-	std::string json_data;
+		data<Schema, Encoding> data;
+	data<Schema, encode::Native> native_data;
 
 	if (read_mode) {
-		auto eov = impl::cli_modifier<Schema, Encoding>::traverse<impl::cli_mode::read>(sch_path, json_data);
+		auto eov = impl::cli_modifier<Schema, encode::Native>::traverse<impl::cli_mode::read>(sch_path, native_data, json_data);
 		if(eov.is_error()){
 			return -1;
 		}
 	} else {
-		auto eov = impl::cli_modifier<Schema, Encoding>::traverse<impl::cli_mode::write>(sch_path, json_data);
+		auto eov = impl::cli_modifier<Schema, encode::Native>::traverse<impl::cli_mode::write>(sch_path, native_data, json_data);
 		if(eov.is_error()){
 			return -1;
 		}
-- 
cgit v1.2.3