359 lines
9.7 KiB
C++
359 lines
9.7 KiB
C++
#pragma once
|
|
|
|
#include <VTAll.hpp>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <deque>
|
|
#include <map>
|
|
#include <stdexcept>
|
|
#include <cinttypes>
|
|
#include <initializer_list>
|
|
#include <type_traits>
|
|
#include <memory>
|
|
|
|
namespace Unvirt::CmdHelper {
|
|
|
|
class CmdSplitter {
|
|
public:
|
|
using Result_t = std::deque<std::u8string>;
|
|
private:
|
|
enum class StateType : int {
|
|
SPACE,
|
|
SINGLE,
|
|
DOUBLE,
|
|
ESCAPE,
|
|
NORMAL
|
|
};
|
|
|
|
public:
|
|
CmdSplitter() :
|
|
m_CurrentChar(u8'\0'), m_Buffer(), m_Result(), m_ValidResult(false),
|
|
m_State(StateType::NORMAL), m_PrevState(StateType::NORMAL) {}
|
|
~CmdSplitter() {}
|
|
YYCC_DEL_CLS_COPY_MOVE(CmdSplitter);
|
|
|
|
bool Convert(const std::u8string& u8cmd);
|
|
const Result_t& GetResult() const;
|
|
|
|
private:
|
|
void ProcSpace();
|
|
void ProcSingle();
|
|
void ProcDouble();
|
|
void ProcEscape();
|
|
void ProcNormal();
|
|
|
|
char8_t m_CurrentChar;
|
|
std::u8string m_Buffer;
|
|
Result_t m_Result;
|
|
bool m_ValidResult;
|
|
StateType m_State, m_PrevState;
|
|
};
|
|
|
|
#pragma region ArgumentsMap
|
|
|
|
namespace ArgumentsMapItem {
|
|
|
|
class AbstractItem {
|
|
public:
|
|
AbstractItem() {}
|
|
virtual ~AbstractItem() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(AbstractItem);
|
|
};
|
|
|
|
template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty>, int> = 0>
|
|
class ArithmeticItem : public AbstractItem {
|
|
public:
|
|
ArithmeticItem(_Ty value) : AbstractItem(), m_Data(value) {}
|
|
virtual ~ArithmeticItem() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(ArithmeticItem);
|
|
public:
|
|
_Ty Get() const { return m_Data; }
|
|
protected:
|
|
_Ty m_Data;
|
|
};
|
|
|
|
template<typename _Ty, std::enable_if_t<std::is_arithmetic_v<_Ty>, int> = 0>
|
|
class ArithmeticArrayItem : public AbstractItem {
|
|
public:
|
|
ArithmeticArrayItem(const std::vector<_Ty>& values) : AbstractItem(), m_Data(values) {}
|
|
virtual ~ArithmeticArrayItem() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(ArithmeticArrayItem);
|
|
public:
|
|
const std::vector<_Ty>& Get() const { return m_Data; }
|
|
protected:
|
|
std::vector<_Ty> m_Data;
|
|
};
|
|
|
|
class StringItem : public AbstractItem {
|
|
public:
|
|
StringItem(const std::u8string_view& value) : AbstractItem(), m_Data(value) {}
|
|
virtual ~StringItem() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(StringItem);
|
|
public:
|
|
const std::u8string& Get() const { return m_Data; }
|
|
protected:
|
|
std::u8string m_Data;
|
|
};
|
|
|
|
class StringArrayItem : public AbstractItem {
|
|
public:
|
|
StringArrayItem(const std::vector<std::u8string>& value) : AbstractItem(), m_Data(value) {}
|
|
virtual ~StringArrayItem() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(StringArrayItem);
|
|
public:
|
|
const std::vector<std::u8string>& Get() const { return m_Data; }
|
|
protected:
|
|
std::vector<std::u8string> m_Data;
|
|
};
|
|
|
|
}
|
|
|
|
class ArgumentsMap {
|
|
public:
|
|
ArgumentsMap() : m_Data() {}
|
|
~ArgumentsMap() {}
|
|
YYCC_DEF_CLS_COPY_MOVE(ArgumentsMap);
|
|
|
|
protected:
|
|
std::map<std::u8string, std::unique_ptr<ArgumentsMapItem::AbstractItem>> m_Data;
|
|
|
|
public:
|
|
template<class _Ty, class... _Types, std::enable_if_t<std::is_base_of_v<ArgumentsMapItem::AbstractItem, _Ty>, int> = 0>
|
|
void Add(const std::u8string_view& key, _Types&&... args) {
|
|
// check argument
|
|
if (key.empty())
|
|
throw std::invalid_argument("argument key should not be empty");
|
|
// insert into data
|
|
auto result = m_Data.try_emplace(std::u8string(key), std::make_unique<_Ty>(std::forward<_Types>(args)...));
|
|
if (!result.second)
|
|
throw std::runtime_error("try to add an existing key.");
|
|
}
|
|
template<class _Ty, std::enable_if_t<std::is_base_of_v<ArgumentsMapItem::AbstractItem, _Ty>, int> = 0>
|
|
const _Ty& Get() const {
|
|
// check argument
|
|
if (key.empty())
|
|
throw std::invalid_argument("argument key should not be empty");
|
|
// find key first
|
|
auto finder = m_Data.find(std::u8string(key));
|
|
if (finder == m_Data.end())
|
|
throw std::runtime_error("try to get a non-existent key.");
|
|
// get stored value data
|
|
const ArgumentsMapItem::AbstractItem& value = *finder->second.get();
|
|
return static_cast<const _Ty&>(value);
|
|
}
|
|
void Remove(const std::u8string_view& key) {
|
|
// check argument
|
|
if (key.empty())
|
|
throw std::invalid_argument("argument key should not be empty");
|
|
// remove and return remove result.
|
|
if (m_Data.erase(std::u8string(key)) == 0u)
|
|
throw std::runtime_error("try to delete a non-existent key.");
|
|
}
|
|
};
|
|
|
|
#pragma endregion
|
|
|
|
class HelpDocument {
|
|
public:
|
|
HelpDocument();
|
|
~HelpDocument();
|
|
YYCC_DEF_CLS_COPY_MOVE(HelpDocument);
|
|
|
|
public:
|
|
void Push(const std::u8string& arg_name, const std::u8string& arg_desc);
|
|
void Pop();
|
|
void Terminate(std::u8string& command_desc);
|
|
void Print();
|
|
|
|
protected:
|
|
struct StackItem {
|
|
StackItem();
|
|
StackItem(const std::u8string& name, const std::u8string& desc);
|
|
YYCC_DEF_CLS_COPY_MOVE(StackItem);
|
|
|
|
std::u8string m_Name;
|
|
std::u8string m_Desc;
|
|
};
|
|
std::deque<StackItem> m_Stack;
|
|
|
|
struct ResultItem {
|
|
ResultItem();
|
|
ResultItem(const std::u8string& cmd_desc, const std::deque<StackItem>& arg_desc);
|
|
YYCC_DEF_CLS_COPY_MOVE(ResultItem);
|
|
|
|
std::u8string m_CmdDesc;
|
|
std::vector<StackItem> m_ArgDesc;
|
|
};
|
|
std::vector<ResultItem> m_Results;
|
|
};
|
|
|
|
class AbstractNode {
|
|
friend class CommandRoot;
|
|
public:
|
|
using ExecutionFct = void(*)(const ArgumentsMap&);
|
|
|
|
public:
|
|
AbstractNode();
|
|
virtual ~AbstractNode();
|
|
YYCC_DEF_CLS_COPY_MOVE(AbstractNode);
|
|
|
|
AbstractNode* Then(AbstractNode*);
|
|
AbstractNode* Executes(ExecutionFct, const char* = nullptr);
|
|
AbstractNode* Comment(const char*);
|
|
|
|
protected:
|
|
void Help(HelpDocument& doc);
|
|
bool Consume(CmdSplitter::Result_t& cmds, ArgumentsMap& am);
|
|
virtual bool IsConflictWith(AbstractNode* node) = 0;
|
|
virtual bool IsArgument() = 0;
|
|
virtual std::u8string HelpSymbol() = 0;
|
|
virtual bool BeginConsume(const std::u8string& cur_cmd, ArgumentsMap& am) = 0;
|
|
virtual void EndConsume(ArgumentsMap*) = 0;
|
|
|
|
protected:
|
|
std::vector<std::unique_ptr<AbstractNode>> m_Nodes;
|
|
ExecutionFct m_Execution;
|
|
std::string m_ExecutionDesc;
|
|
std::string m_Comment;
|
|
};
|
|
|
|
class CommandRoot : public AbstractNode {
|
|
public:
|
|
CommandRoot();
|
|
virtual ~CommandRoot();
|
|
YYCC_DEL_CLS_COPY_MOVE(CommandRoot);
|
|
|
|
// Root use special consume and help functions.
|
|
bool RootConsume(std::deque<std::string>&);
|
|
HelpDocument* RootHelp();
|
|
|
|
public:
|
|
virtual NodeType GetNodeType() override { throw std::logic_error("Root can not be called."); }
|
|
virtual bool IsConflictWith(AbstractNode*) override { throw std::logic_error("Root can not be called."); }
|
|
protected:
|
|
virtual std::string GetHelpSymbol() override { throw std::logic_error("Root can not be called."); }
|
|
virtual bool BeginAccept(const std::string&, ArgumentsMap*) override { throw std::logic_error("Root can not be called."); }
|
|
virtual void EndAccept(ArgumentsMap*) override { throw std::logic_error("Root can not be called."); }
|
|
};
|
|
|
|
class Literal : public AbstractNode {
|
|
friend class Choice;
|
|
friend class AbstractArgument;
|
|
public:
|
|
Literal(const char* words);
|
|
virtual ~Literal();
|
|
YYCC_DEL_CLS_COPY_MOVE(Literal);
|
|
|
|
public:
|
|
virtual NodeType GetNodeType() override;
|
|
virtual bool IsConflictWith(AbstractNode* node) override;
|
|
protected:
|
|
virtual std::string GetHelpSymbol() override;
|
|
virtual bool BeginAccept(const std::string&, ArgumentsMap*) override;
|
|
virtual void EndAccept(ArgumentsMap*) override;
|
|
|
|
std::string m_Literal;
|
|
};
|
|
|
|
class Choice : public AbstractNode {
|
|
friend class Literal;
|
|
friend class AbstractArgument;
|
|
public:
|
|
using vType = size_t;
|
|
Choice(const char* argname, const std::initializer_list<std::string>& vocabulary);
|
|
virtual ~Choice();
|
|
YYCC_DEL_CLS_COPY_MOVE(Choice);
|
|
|
|
vType* GetIndex();
|
|
|
|
public:
|
|
virtual NodeType GetNodeType() override;
|
|
virtual bool IsConflictWith(AbstractNode* node) override;
|
|
protected:
|
|
virtual std::string GetHelpSymbol() override;
|
|
virtual bool BeginAccept(const std::string&, ArgumentsMap*) override;
|
|
virtual void EndAccept(ArgumentsMap*) override;
|
|
|
|
std::string m_ChoiceName;
|
|
std::vector<std::string> m_Vocabulary;
|
|
bool m_Accepted;
|
|
size_t m_GottenIndex;
|
|
};
|
|
|
|
class AbstractArgument : public AbstractNode {
|
|
friend class Literal;
|
|
friend class Choice;
|
|
public:
|
|
AbstractArgument(const char* argname);
|
|
virtual ~AbstractArgument();
|
|
YYCC_DEL_CLS_COPY_MOVE(AbstractArgument);
|
|
|
|
template<class T>
|
|
T GetData() {
|
|
return reinterpret_cast<T>(m_ParsedData);
|
|
}
|
|
|
|
public:
|
|
virtual NodeType GetNodeType() override;
|
|
virtual bool IsConflictWith(AbstractNode* node) override;
|
|
protected:
|
|
virtual std::string GetHelpSymbol() override;
|
|
virtual bool BeginAccept(const std::string&, ArgumentsMap*) override;
|
|
virtual void EndAccept(ArgumentsMap*) override;
|
|
|
|
virtual bool BeginParse(const std::string&) = 0;
|
|
virtual void EndParse() = 0;
|
|
|
|
std::string m_ArgName;
|
|
bool m_Accepted;
|
|
void* m_ParsedData;
|
|
};
|
|
|
|
/**
|
|
* @brief Return true mean this value can accept.
|
|
*/
|
|
using IntLimit = std::function<bool(int32_t)>;
|
|
class IntArgument : public AbstractArgument {
|
|
public:
|
|
using vType = int32_t;
|
|
IntArgument(const char* argname, IntLimit limit = nullptr) :
|
|
AbstractArgument(argname), m_IntLimit(limit) {}
|
|
virtual ~IntArgument() {}
|
|
YYCC_DEL_CLS_COPY_MOVE(IntArgument);
|
|
|
|
protected:
|
|
virtual bool BeginParse(const std::string&) override;
|
|
virtual void EndParse() override;
|
|
|
|
IntLimit m_IntLimit;
|
|
};
|
|
|
|
class StringArgument : public AbstractArgument {
|
|
public:
|
|
using vType = std::string;
|
|
StringArgument(const char* argname) :
|
|
AbstractArgument(argname) {}
|
|
virtual ~StringArgument() {}
|
|
YYCC_DEL_CLS_COPY_MOVE(StringArgument);
|
|
|
|
protected:
|
|
virtual bool BeginParse(const std::string&) override;
|
|
virtual void EndParse() override;
|
|
};
|
|
|
|
class EncodingArgument : public AbstractArgument {
|
|
public:
|
|
using vType = std::vector<std::string>;
|
|
EncodingArgument(const char* argname) :
|
|
AbstractArgument(argname) {}
|
|
virtual ~EncodingArgument() {}
|
|
YYCC_DEL_CLS_COPY_MOVE(EncodingArgument);
|
|
|
|
protected:
|
|
virtual bool BeginParse(const std::string&) override;
|
|
virtual void EndParse() override;
|
|
};
|
|
|
|
}
|