Refactored arguments

include/cmd/args/arg.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <vector>
+#include <unordered_map>
+
+#include "ast/ast_component.hpp"
+#include "util/input.hpp"
+
+#include "cmd/args/arg_generic.hpp"
+#include "cmd/args/arg_input.hpp"
+#include "cmd/args/arg_manager.hpp"
+
+namespace fsh{
+
+class ArgFactory {
+public:
+    using FlagNode = std::optional<std::string>&;
+    using ArgNodes = std::vector<std::shared_ptr<CommandArgumentNode > >;
+    using BuildFunc = std::shared_ptr<_Argument> (*) (void);
+
+    struct ArgRule 
+    {
+        BuildFunc build;
+        bool mandatory;
+        bool extends;
+    };
+
+    struct FlagRule
+    {
+        BuildFunc build;
+        bool specialinput; //Not implemented
+        bool capturing;
+        bool extends; //Not implemented
+    };
+
+
+    void add_input_rule() {
+        has_input = true;
+        pos_arg_rules.push_back({&_Argument::create<ArgInput>, false, false});
+    }
+
+    template<typename T>
+    void add_rule(bool mandatory, bool extends = false) {
+        pos_arg_rules.push_back({&_Argument::create<Argument<T> >, mandatory, extends});
+    }
+
+    template<typename T = bool >
+    void add_rule(const std::string name, bool capturing = false) {
+        flag_rules[name] = {_Argument::create<Argument<T> >, false, capturing, false};
+    }
+
+    void parse(ArgManager& manager, ArgNodes& vec, FlagNode flag);
+    bool ghas_input() {return has_input;}
+
+private:
+    std::vector<ArgRule> pos_arg_rules;
+    std::unordered_map<std::string, FlagRule> flag_rules;
+    bool has_input = false;
+
+    void parse_flag(ArgManager& manager, FlagNode flag); 
+    std::shared_ptr<_Argument> build_arg(BuildFunc build_func, const std::string& str);
+    std::shared_ptr<_Argument> build_arg(BuildFunc build_func, std::shared_ptr<CommandArgumentNode> cmd_arg);
+};
+}

include/cmd/args/arg_base.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+
+#include "ast/ast_component.hpp"
+
+namespace fsh{
+
+class _Argument {
+public:
+    virtual void svalue(const std::string& can, const Lexer::TokenType& type = Lexer::TokenType::FLAG) {}
+    virtual void svalue(std::shared_ptr<CommandArgumentNode> can) {
+        svalue(can->gvalue(), can->gtoken_type());
+    }
+
+    template<typename T>
+    static std::shared_ptr<_Argument> create() {return std::make_shared<T>();}
+protected:
+    _Argument(){} 
+};
+
+}

include/cmd/args/arg_generic.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+#include "cmd/args/arg_base.hpp"
+#include "ast/ast_component.hpp"
+
+namespace fsh{
+
+template<typename T>
+class Argument : public _Argument {
+public:
+    static T& get(std::shared_ptr<_Argument> a) {
+       return std::dynamic_pointer_cast<Argument<T> >(a)->gvalue();
+    }
+
+    Argument() {} 
+
+    virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
+    virtual T& gvalue() {return value;}
+private:
+    bool is_string_literal; // Currently no getter
+    T value;
+};
+
+template<class T>
+void Argument<T>::svalue(const std::string& val, const Lexer::TokenType& type) {
+    if constexpr (std::is_same_v<T, std::string>) {
+        value = val;
+    } else {
+        std::stringstream ss_val(val);
+        if(!(ss_val >> value)) {
+            throw std::invalid_argument("Incorrect type");
+        }
+    }
+    is_string_literal = type == Lexer::TokenType::STRING_LITERAL; 
+}
+
+}

include/cmd/args/arg_input.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+
+#include "cmd/args/arg_base.hpp"
+
+namespace fsh{
+
+class ArgInput : public _Argument {
+public:
+    static std::istream& get(std::shared_ptr<_Argument> a) {
+        return std::dynamic_pointer_cast<ArgInput>(a)->gvalue();
+    }
+
+    ArgInput() {} 
+
+    virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
+    virtual std::istream& gvalue();
+
+private:
+    std::optional<std::stringstream> str;
+    std::optional<std::ifstream> file;
+};
+
+}

include/cmd/args/arg_manager.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include "cmd/args/arg_generic.hpp"
+#include "cmd/args/arg_input.hpp"
+#include "util/input.hpp"
+
+namespace fsh{
+
+class ArgManager {
+    friend class ArgFactory;
+
+    using PosArgs = std::vector<std::shared_ptr<_Argument> >;
+    using FlagOpts = std::unordered_map< std::string ,std::shared_ptr<_Argument> >;
+
+public:
+    ArgManager() {}
+
+
+    std::istream& get_input(const unsigned int id) {
+        if(id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
+        return util::cin;
+    }
+
+    template<typename T>
+    std::optional<T> get(const unsigned int id) {
+        if((unsigned int) id < pos_argument.size()) return Argument<T>::get(pos_argument[id]);
+        return std::make_optional<T>();
+    }
+    template<typename T>
+    std::optional<T> get(const std::string& id) {
+        if(flags.find(id) != flags.end()) return Argument<T>::get(flags[id]);
+        return std::make_optional<T>();
+    }
+    bool get(const std::string& id) {
+        return flags.find(id) != flags.end();
+    }
+
+    void push_arg(std::shared_ptr<_Argument> arg) {
+        pos_argument.push_back(arg);
+    }
+    void push_flag(const std::string &id,std::shared_ptr<_Argument> arg = nullptr) {
+        flags[id] = arg;
+    }
+    
+    private:
+    PosArgs pos_argument;
+    FlagOpts flags;
+};
+}