Pimpest/fsh-oop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

Massive reformating and cleanup

Browse Source
This commit is contained in:
Pimpest
2024-12-06 21:07:54 +01:00
parent 79390b94b7
commit d2cbdc2910
33 changed files with 1030 additions and 1100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
include/cmd/args/arg.hpp
View File

@ -13,55 +13,53 @@
#include "cmd/args/arg_input.hpp"
#include "cmd/args/arg_manager.hpp"
namespace fsh{
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);
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 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);
};
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);
};
}

25
include/cmd/args/arg_base.hpp
View File

@ -4,19 +4,20 @@
#include "ast/ast_component.hpp"
namespace fsh{
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());
}
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(){}
};
template <typename T>
static std::shared_ptr<_Argument> create() {
return std::make_shared<T>();
}
protected:
_Argument() {}
};
}

45
include/cmd/args/arg_generic.hpp
View File

@ -5,35 +5,32 @@
#include "cmd/args/arg_base.hpp"
#include "ast/ast_component.hpp"
namespace fsh{
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();
}
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() {}
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;
};
virtual void svalue(const std::string& val, const Lexer::TokenType& type) override;
virtual T& gvalue() { return 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");
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;
}
is_string_literal = type == Lexer::TokenType::STRING_LITERAL;
}
}

26
include/cmd/args/arg_input.hpp
View File

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

64
include/cmd/args/arg_manager.hpp
View File

@ -3,46 +3,40 @@
#include "cmd/args/arg_input.hpp"
#include "util/input.hpp"
namespace fsh{
namespace fsh {
class ArgManager {
friend class ArgFactory;
class ArgManager {
friend class ArgFactory;
using PosArgs = std::vector<std::shared_ptr<_Argument> >;
using FlagOpts = std::unordered_map< std::string ,std::shared_ptr<_Argument> >;
using PosArgs = std::vector<std::shared_ptr<_Argument> >;
using FlagOpts = std::unordered_map<std::string, std::shared_ptr<_Argument> >;
public:
ArgManager() {}
public:
ArgManager() {}
std::istream& get_input(const unsigned int id) {
if (id < pos_argument.size()) return ArgInput::get(pos_argument[id]);
return util::cin;
}
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 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();
}
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;
};
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;
};
}