WsParser_VS/ArgsParser/argsparser.cpp

#include "argsparser.h"

using namespace args_parse;
using namespace std;

__ArgvPackImpls::__ArgvPackImpls(const QString& means, ParamType t) : means_store(means), type_store(t) { }

// ͨ¹ý IArgvPack ¼Ì³Ð
ParamType __ArgvPackImpls::paramType() const {
	return type_store;
}

QString __ArgvPackImpls::means() const {
	return means_store;
}

void __ArgvPackImpls::setValue(const QString& v) {
	this->value_store = v;
}

QString __ArgvPackImpls::value() const {
	return value_store;
}

FloatKeyValue::FloatKeyValue(const QString& key, const QString& means, bool optional) :
	__FloatArgvImpl(key, means, optional) { }

QString __FloatArgvImpl::bindKey() const {
	return key_name;
}

bool __FloatArgvImpl::optional() const {
	return optional_value;
}

QString args_parse::FloatKeyValue::placeHolder() const {
	if (optional())
		return QString("[--%1 <%2>]").arg(bindKey(), bindKey());
	return QString("--%1 <%2>").arg(bindKey(), bindKey());
}

int FloatKeyValue::matchLenth() const {
	return 2;
}

bool FloatKeyValue::parse(const QList<QString> args, int start) {
	auto args_t = args[start];
	auto args_v = args[start + 1];
	if (args_t == bindKey())
		setValue(args_v);
	return args_t == bindKey();
}

IndexParam::IndexParam(const QString& place_v, const QString& means)
	: __ArgvPackImpls(means, ParamType::IndexParam), _place_holder(place_v) { }

QString args_parse::IndexParam::placeHolder() const {
	return QString("<%1>").arg(_place_holder);
}

int IndexParam::matchLenth() const {
	return 1;
}

bool IndexParam::parse(const QList<QString> args, int start) {
	setValue(args[start]);
	return true;
}

__FloatArgvImpl::__FloatArgvImpl(const QString& key, const QString& means, bool optional)
	: __ArgvPackImpls(means, ParamType::FloatParam), key_name(key), optional_value(optional) { }

FloatOption::FloatOption(const QString& key, const QString& means, bool opt)
	: __FloatArgvImpl(key, means, opt) {
	setValue(u8"0");
}

QString args_parse::FloatOption::placeHolder() const {
	if (optional())
		return QString("[--%1]").arg(bindKey());
	return QString("--%1").arg(bindKey());
}

int FloatOption::matchLenth() const {
	return 1;
}

bool FloatOption::parse(const QList<QString> args, int start) {
	auto args_t = args[start];
	setValue(QString::number(args_t == bindKey()));
	return  args_t == bindKey();
}

MatchMode::MatchMode(const QList<shared_ptr<IArgvPack>> mode, int mode_code)
	:args_mode(mode), code_store(mode_code) { }

/**
* @brief »ñȡģʽ´úÂë
* @return ģʽ´úÂë
*/

int MatchMode::modeCode() const {
	return code_store;
}

/**
* @brief »ñȡģʽƥÅä½á¹û
* @return ģʽƥÅä½á¹û
*/

QList<shared_ptr<IArgvPack>> MatchMode::result() const {
	return args_mode;
}

/**
* @brief ½âÎöÆ¥Åä²ÎÊý
*/

bool MatchMode::parse(const QList<QString>& args, int argv_index, int parse_index) {
	if (argv_index >= args.size())
		return true;

	// »ñȡģʽƥÅäµ¥Ôª
	auto parse_unit = args_mode[parse_index];
	switch (parse_unit->paramType()) {
		case ParamType::IndexParam:// ¹Ì¶¨Î»ÖÃË÷ÒýÆ¥Åä
			{
				parse_unit->parse(args, argv_index);
				// ¼ÌÐøÆ¥ÅäÏÂÒ»¸öΪֹ
				return parse(args, argv_index + parse_unit->matchLenth(), parse_index + 1);
			}break;
		case ParamType::FloatParam:// ¸¡¶¯²ÎÊýÆ¥Åä
			{
				QList<shared_ptr<__FloatArgvImpl>> float_parsers;

				for (auto& unit : args_mode) {
					if (unit->paramType() == ParamType::FloatParam)
						float_parsers << dynamic_pointer_cast<__FloatArgvImpl>(unit);
				}

				for (auto& unit : float_parsers) {
					if (unit->matchLenth() + argv_index > args.size())
						continue;

					auto result = unit->parse(args, argv_index);
					if (result)
						if (parse(args, argv_index + unit->matchLenth(), parse_index + 1))
							return true;
						else if (!result && unit->optional())
							if (parse(args, argv_index, parse_index + 1))
								return true;
				}
			}break;
	}

	return false;
}

void ArgsParser::loadMode(int mode_code, const QList<shared_ptr<IArgvPack>>& args_model) {
	this->match_modes.append(make_shared<MatchMode>(args_model, mode_code));
}

tuple<int, QList<shared_ptr<IArgvPack>>> ArgsParser::parse(int argc, char* argv[]) {
	// ¾ÛºÏ²ÎÊýÊý×é
	QList<QString> args_list;
	for (int idx = 0; idx < argc; idx++) {
		auto argv_str = QString::fromLocal8Bit(argv[idx]);
		args_list.append(argv_str);
	}

	// ö¾ÙģʽƥÅä
	for (auto& minst : this->match_modes) {
		if (minst->parse(args_list, 0, 0))
			return tuple<int, QList<shared_ptr<IArgvPack>>>(minst->modeCode(), minst->result());
	}

	return tuple<int, QList<shared_ptr<IArgvPack>>>(0, QList<shared_ptr<IArgvPack>>());
}