QBinaryTranslate/TranslateUI/TranslateBasic.cpp

#include "TranslateBasic.h"

using namespace extract;
using namespace size_provider;

TranslateBasic::TranslateBasic()
{
	// extractor type-list
	std::shared_ptr<ExtractUnit> u_ptr = std::make_shared<AsBitCombine>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsInteger>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsUnsigned>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsString>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsHex>();
	_extractor_types[u_ptr->name()] = u_ptr;
	this->_default_translate_rule = u_ptr;

	u_ptr = std::make_shared<AsFloat>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsDouble>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsList>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsUnion>();
	_extractor_types[u_ptr->name()] = u_ptr;

	u_ptr = std::make_shared<AsRuleSet>();
	_extractor_types[u_ptr->name()] = u_ptr;

	// size-provider type-list
	std::shared_ptr<SizeProvider> sz_ptr = std::make_shared<ConstNumberProvider>();
	this->_default_size_provider = sz_ptr;
	_size_provider_types[sz_ptr->name()] = sz_ptr;

	sz_ptr = std::make_shared<InterpretedNumberPrivider>();
	_size_provider_types[sz_ptr->name()] = sz_ptr;
}

std::shared_ptr<ExtractUnit> TranslateBasic::defaultExtractUnit() const
{
	return _default_translate_rule;
}

std::shared_ptr<SizeProvider> TranslateBasic::defaultSizeProvider() const
{
	return _default_size_provider;
}

std::shared_ptr<RuleMatch> TranslateBasic::defaultRuleMatch() const
{
	return _default_rule_match;
}

QHash<QString, std::shared_ptr<ExtractUnit>> TranslateBasic::extractUnitList() const
{
	return _extractor_types;
}

void TranslateBasic::setCustomRule(const QString& name, std::shared_ptr<extract::AsRuleSet> inst)
{
	auto exist = std::count_if(
		this->_custom_rule_types.begin(), this->_custom_rule_types.end(),
		[=](std::shared_ptr<extract::AsRuleSet> v) {
			return v->name() == name;
		});
	assert("RuleName<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD>" && !exist);

	inst->setCustomName(name);
	this->_custom_rule_types << inst;
}

void TranslateBasic::removeCustomRule(const QString& name)
{
	for (auto idxp = 0; idxp< this->_custom_rule_types.size(); idxp++) {
		auto rule = this->_custom_rule_types.at(idxp);
		if (rule->customName() == name) {
			this->_custom_rule_types.removeAt(idxp--);
			return;
		}
	}

	assert("ָ<EFBFBD><EFBFBD>RuleName<EFBFBD><EFBFBD><EFBFBD>Ϸ<EFBFBD>" && 0);
}

QHash<QString, std::shared_ptr<extract::AsRuleSet>> TranslateBasic::customRules() const
{
	QHash<QString, std::shared_ptr<extract::AsRuleSet>> value_set;
	for (auto instv : this->_custom_rule_types)
		value_set[instv->customName()] = instv;
	return value_set;
}

QHash<QString, std::shared_ptr<SizeProvider>> TranslateBasic::sizeProviderList() const
{
	return _size_provider_types;
}

QHash<QString, std::shared_ptr<RuleMatch>> TranslateBasic::ruleMatchList() const
{
	return _rule_match_types;
}

void ConstNumberProvider::bindInput(std::shared_ptr<DataAccessContext> inst)
{

}

QString ConstNumberProvider::name() const
{
	return NAME(ConstNumberProvider);
}

int32_t ConstNumberProvider::value(const QString& expr) const
{
	return expr.toInt();
}

void ConstNumberProvider::setExpression(const QString& expr)
{
	this->_number._value_string = expr;
}

QString ConstNumberProvider::expression() const
{
	return this->_number._value_string;
}

void ConstNumberProvider::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonObject& obj)
{
	STRING_PEAK(_number._value_string, obj);
}

void ConstNumberProvider::saveTo(QJsonObject& obj) const
{
	STRING_SAVE(_number._value_string, obj);
}

std::shared_ptr<Serializable> ConstNumberProvider::newDefault() const
{
	return std::make_shared<ConstNumberProvider>();
}

void InterpretedNumberPrivider::bindInput(std::shared_ptr<DataAccessContext> inst)
{
	this->_refer._context_inst = inst;
}

QString InterpretedNumberPrivider::name() const
{
	return NAME(InterpretedNumberPrivider);
}

#include <QMetaType>
int32_t InterpretedNumberPrivider::value(const QString& expr) const
{
	auto value = this->_refer._context_inst->get(expr);
	if (value.userType() == QMetaType::Int)
		return value.toInt();

	return 0;
}

void InterpretedNumberPrivider::setExpression(const QString& expr)
{
	this->_refer._field_refer = expr;
}

QString InterpretedNumberPrivider::expression() const
{
	return this->_refer._field_refer;
}

void InterpretedNumberPrivider::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonObject& obj)
{
	STRING_PEAK(this->_refer._field_refer, obj);
}

void InterpretedNumberPrivider::saveTo(QJsonObject& obj) const
{
	STRING_SAVE(this->_refer._field_refer, obj);
}

std::shared_ptr<Serializable> InterpretedNumberPrivider::newDefault() const
{
	return std::make_shared<InterpretedNumberPrivider>();
}

void ValueAccessContext::init(const QString& field, std::shared_ptr<DataAccessContext> parent)
{
	this->_cascade._current_field = field;

	if (parent)
		parent->setChild(field, this->shared_from_this());
}

void ValueAccessContext::setChild(const QString& field, std::shared_ptr<DataAccessContext> inst)
{
	this->_cascade._children_context[field] = inst;
}

void ValueAccessContext::append(const QVariant& value)
{
	this->_cascade._current_value = value;
}

QVariant ValueAccessContext::get(const QString& unique_key) const
{
	if (_cascade._current_field == unique_key)
		return _cascade._current_value;

	for (auto unit : _cascade._children_context)
	{
		auto value = unit->get(unique_key);
		if (value.isValid())
			return value;
	}
	return QVariant();
}

bool FieldManagerLayer::bindCurrent(const QString& unique_key)
{
	for (auto index = 0; index < __Private::_fields_map.size(); ++index) {
		auto pair = __Private::_fields_map[index];
		if (pair.first == unique_key) {
			__Private::_fields_map = __Private::_fields_map.mid(0, index);
			return true;
		}
	}
	return false;
}

QHash<QString, DataType> FieldManagerLayer::prevFields() const
{
	QHash<QString, DataType> fields;
	for (auto pair : __Private::_fields_map)
		fields[pair.first] = pair.second;

	return fields;
}

void FieldManagerLayer::clear()
{
	__Private::_fields_map.clear();
}

FieldManagerLayer::FieldManagerLayer(const QString& self, std::shared_ptr<ScopeFieldsSetter> instp)
{
	_setter._rule_name = self;
	_setter._parent_setter = instp;
}

#include <stdexcept>
void FieldManagerLayer::setField(const QString& name, DataType type)
{
	if (_setter._parent_setter)
		_setter._parent_setter->setField(QString("%1.%2").arg(_setter._rule_name, name), type);
	else {
		for (auto pair : __Private::_fields_map) {
			if (pair.first == name)
				throw new std::invalid_argument("<EFBFBD>ֶ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD>");
		}
		__Private::_fields_map << std::make_pair(name, type);
	}
}
QList<std::pair<QString, DataType>> FieldManagerLayer::__Private::_fields_map;