From ae673253322f545e4b59a762ab54f01b9073c6ef Mon Sep 17 00:00:00 2001 From: codeboss <2422523675@qq.com> Date: Sat, 2 Aug 2025 15:02:35 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9E=84=E5=BB=BASubRule=E5=BA=95=E5=B1=82?= =?UTF-8?q?=E7=BB=93=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TranslateUI/SequenceView.cpp | 10 +- TranslateUI/TranslateBasic.cpp | 35 +++++- TranslateUI/TranslateBasic.h | 24 +++- TranslateUI/common.h | 17 ++- TranslateUI/convert_basic.cpp | 8 +- TranslateUI/extract_basic.cpp | 193 +++++++++++++++++++++++++++------ TranslateUI/extract_basic.h | 30 ++++- 7 files changed, 259 insertions(+), 58 deletions(-) diff --git a/TranslateUI/SequenceView.cpp b/TranslateUI/SequenceView.cpp index 5b55d02..839ee0b 100644 --- a/TranslateUI/SequenceView.cpp +++ b/TranslateUI/SequenceView.cpp @@ -59,14 +59,14 @@ void SequenceRulesView::currentRuleRefresh(const QModelIndex& idx) void SequenceRulesView::peersRuleChanged(const QModelIndex& idx) { auto rule_idx = idx.sibling(idx.row(), 2); - auto rule_nm = base->extactors()[rule_idx.data(Qt::DisplayRole).toString()]; + auto rule_nm = base->extractUnitList()[rule_idx.data(Qt::DisplayRole).toString()]; auto new_inst = std::dynamic_pointer_cast(rule_nm->newDefault()); _rule_sequence.replace(idx.row(), new_inst); if (typeid(*new_inst.get()) == typeid(BytesAsList)) { auto conv = std::dynamic_pointer_cast(new_inst); if (!conv->elementRule()) { - conv->appendElementRule(this->base->defaultRule()); + conv->appendElementRule(this->base->defaultExtractUnit()); } if (!conv->sizeProvider()) { @@ -122,11 +122,11 @@ void SequenceRulesView::addTranslateUnit() QList new_row; new_row << new QStandardItem(QString(u8"rule_%1").arg(row_cnt)); new_row << new QStandardItem(u8"0"); - new_row << new QStandardItem(base->defaultRule()->name()); + new_row << new QStandardItem(base->defaultExtractUnit()->name()); new_row << new QStandardItem(u8"1"); new_row.last()->setEditable(false); - auto curr_rule = base->defaultRule()->newDefault(); + auto curr_rule = base->defaultExtractUnit()->newDefault(); this->_rule_sequence << std::static_pointer_cast(curr_rule); auto hex_rule = std::static_pointer_cast(curr_rule); @@ -166,7 +166,7 @@ QWidget* RuleSelectDelegate::createEditor(QWidget* parent, const QStyleOptionVie void RuleSelectDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const { - auto rule_names = this->_kernel->extactors().keys(); + auto rule_names = this->_kernel->extractUnitList().keys(); std::sort(rule_names.begin(), rule_names.end()); auto combo = dynamic_cast(editor); diff --git a/TranslateUI/TranslateBasic.cpp b/TranslateUI/TranslateBasic.cpp index d66277e..30f5761 100644 --- a/TranslateUI/TranslateBasic.cpp +++ b/TranslateUI/TranslateBasic.cpp @@ -37,7 +37,7 @@ TranslateBasic::TranslateBasic() _size_provider_types[sz_ptr->name()] = sz_ptr; } -std::shared_ptr TranslateBasic::defaultRule() const +std::shared_ptr TranslateBasic::defaultExtractUnit() const { return _default_translate_rule; } @@ -47,16 +47,26 @@ std::shared_ptr TranslateBasic::defaultSizeProvider() const return _default_size_provider; } -QHash> TranslateBasic::extactors() const +std::shared_ptr TranslateBasic::defaultRuleMatch() const +{ + return _default_rule_match; +} + +QHash> TranslateBasic::extractUnitList() const { return _extractor_types; } -QHash> TranslateBasic::sizeProviders() const +QHash> TranslateBasic::sizeProviderList() const { return _size_provider_types; } +QHash> TranslateBasic::ruleMatchList() const +{ + return _rule_match_types; +} + QString ConstNumberProvider::name() const { return NAME(ConstNumberProvider); @@ -69,10 +79,25 @@ int32_t ConstNumberProvider::value(const QString& expr) const void ConstNumberProvider::setExpression(const QString& expr) { - this->_number_value = expr; + this->_number._value_string = expr; } QString ConstNumberProvider::expression() const { - return this->_number_value; + return this->_number._value_string; +} + +void ConstNumberProvider::loadFrom(std::shared_ptr 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 ConstNumberProvider::newDefault() const +{ + return std::make_shared(); } diff --git a/TranslateUI/TranslateBasic.h b/TranslateUI/TranslateBasic.h index b9f4f3e..fd64761 100644 --- a/TranslateUI/TranslateBasic.h +++ b/TranslateUI/TranslateBasic.h @@ -11,21 +11,30 @@ class TranslateBasic { private: QHash> _extractor_types; std::shared_ptr _default_translate_rule = nullptr; + QHash> _size_provider_types; std::shared_ptr _default_size_provider = nullptr; + QHash> _rule_match_types; + std::shared_ptr _default_rule_match = nullptr; + public: TranslateBasic(); - std::shared_ptr defaultRule() const; std::shared_ptr defaultSizeProvider() const; - QHash> extactors() const; - QHash> sizeProviders() const; + QHash> sizeProviderList() const; + std::shared_ptr defaultRuleMatch() const; + QHash> ruleMatchList() const; + + std::shared_ptr defaultExtractUnit() const; + QHash> extractUnitList() const; }; class ConstNumberProvider : public SizeProvider { -private: - QString _number_value; +public: + struct __Private { + QString _value_string; + } _number; public: QString name() const override; @@ -33,4 +42,9 @@ public: int32_t value(const QString& expr) const override; void setExpression(const QString& expr) override; QString expression() const override; + + void loadFrom(std::shared_ptr core, const QJsonObject& obj) override; + void saveTo(QJsonObject& obj) const override; + + std::shared_ptr newDefault() const override; }; diff --git a/TranslateUI/common.h b/TranslateUI/common.h index 26baabd..c98e370 100644 --- a/TranslateUI/common.h +++ b/TranslateUI/common.h @@ -4,12 +4,16 @@ #include #define NAME(u) #u -#define INT32_SAVE(varx) obj[NAME(varx)] = varx; -#define INT32_PEAK(varx) varx = obj[NAME(varx)].toInt(); -#define STRLIST_SAVE(list) obj[NAME(list)] = list.join(";"); -#define STRLIST_PEAK(list) list = obj[NAME(list)].toString().split(";"); -#define STRING_PEAK(codec_name) codec_name = obj[NAME(codec_name)].toString(); -#define STRING_SAVE(codec_name) obj[NAME(codec_name)] = codec_name; +#define INT32_SAVE(varx, obj) obj[NAME(varx)] = varx; +#define INT32_PEAK(varx, obj) varx = obj[NAME(varx)].toInt(); +#define STRLIST_SAVE(list, obj) obj[NAME(list)] = list.join(";"); +#define STRLIST_PEAK(list, obj) list = obj[NAME(list)].toString().split(";"); +#define STRING_PEAK(codec_name, obj) codec_name = obj[NAME(codec_name)].toString(); +#define STRING_SAVE(codec_name, obj) obj[NAME(codec_name)] = codec_name; +#define OBJECT_SAVE(objn, obj) obj[NAME(objn)] = objn; +#define OBJECT_PEAK(objn, obj) objn = obj[NAME(objn)].toObject(); +#define ARRAY_SAVE(objn, obj) obj[NAME(objn)] = objn; +#define ARRAY_PEAK(objn, obj) objn = obj[NAME(objn)].toArray(); class TranslateBasic; /// @@ -48,4 +52,5 @@ enum class DataType { Dbl64, LIST_COLLECTION, UNION_COMBINATE, + SUB_RULE, }; diff --git a/TranslateUI/convert_basic.cpp b/TranslateUI/convert_basic.cpp index 5b99962..9570920 100644 --- a/TranslateUI/convert_basic.cpp +++ b/TranslateUI/convert_basic.cpp @@ -27,21 +27,21 @@ DataType AbstractValueConvert::outType() const void AbstractValueConvert::loadFrom(std::shared_ptr core, const QJsonObject& obj) { auto int_in_type = (int)_in_type; - INT32_PEAK(int_in_type); + INT32_PEAK(int_in_type, obj); _in_type = (DataType)int_in_type; auto int_out_type = (int)_out_type; - INT32_PEAK(int_out_type); + INT32_PEAK(int_out_type, obj); _out_type = (DataType)int_out_type; } void AbstractValueConvert::saveTo(QJsonObject& obj) const { auto int_in_type = (int)_in_type; - INT32_SAVE(int_in_type); + INT32_SAVE(int_in_type, obj); auto int_out_type = (int)_out_type; - INT32_SAVE(int_out_type); + INT32_SAVE(int_out_type, obj); } DoubleWithLSB::DoubleWithLSB() diff --git a/TranslateUI/extract_basic.cpp b/TranslateUI/extract_basic.cpp index fabc2d9..2bc8504 100644 --- a/TranslateUI/extract_basic.cpp +++ b/TranslateUI/extract_basic.cpp @@ -45,14 +45,14 @@ int AbstractExtractor::countWithin() const void AbstractExtractor::loadFrom( std::shared_ptr core, const QJsonObject& obj) { - INT32_PEAK(_abs_data.byte_offset); - INT32_PEAK(_abs_data.byte_count); + INT32_PEAK(_abs_data.byte_offset, obj); + INT32_PEAK(_abs_data.byte_count, obj); } void AbstractExtractor::saveTo(QJsonObject& obj) const { - INT32_SAVE(_abs_data.byte_offset); - INT32_SAVE(_abs_data.byte_count); + INT32_SAVE(_abs_data.byte_offset, obj); + INT32_SAVE(_abs_data.byte_count, obj); } BytesAsHex::BytesAsHex() @@ -117,17 +117,20 @@ QVariant BytesAsBitCombine::parse(const QByteArray& bytes) const return result; } +#include void BytesAsBitCombine::loadFrom( std::shared_ptr core, const QJsonObject& obj) { AbstractExtractor::loadFrom(core, obj); - QStringList value_list; - STRLIST_PEAK(value_list); _combine._switch_options.clear(); - for (auto pair : value_list) { - auto items = pair.split("="); - _combine._switch_options[items.first().toInt()] = items.last(); + QJsonArray arr; + ARRAY_PEAK(arr, obj); + for (auto index = 0; index < arr.size(); ++index) { + auto switch_obj = arr.at(index); + auto key = switch_obj["index"].toInt(); + auto content = switch_obj["content"].toString(); + _combine._switch_options[key] = content; } } @@ -135,13 +138,14 @@ void BytesAsBitCombine::saveTo(QJsonObject& obj) const { AbstractExtractor::saveTo(obj); - QStringList value_list; + QJsonArray arr; for (auto key : _combine._switch_options.keys()) { - auto pair_str = QString("%1=%2").arg(key) - .arg(_combine._switch_options[key]); - value_list << pair_str; + QJsonObject switch_obj; + switch_obj["index"] = key; + switch_obj["content"] = _combine._switch_options[key]; + arr.append(switch_obj); } - STRLIST_SAVE(value_list); + ARRAY_SAVE(arr, obj); } std::shared_ptr BytesAsBitCombine::newDefault() const @@ -214,7 +218,7 @@ void BytesAsString::loadFrom(std::shared_ptr core, const QJsonOb AbstractExtractor::loadFrom(core, obj); QString codec_name; - STRING_PEAK(codec_name); + STRING_PEAK(codec_name, obj); this->_strings._conv_with = QTextCodec::codecForName(codec_name.toLatin1()); } @@ -223,7 +227,7 @@ void BytesAsString::saveTo(QJsonObject& obj) const AbstractExtractor::saveTo(obj); auto codec_name = this->codecName(); - STRING_SAVE(codec_name); + STRING_SAVE(codec_name, obj); } std::shared_ptr BytesAsString::newDefault() const @@ -350,37 +354,55 @@ int BytesAsList::countWithin() const #include "TranslateBasic.h" void BytesAsList::loadFrom(std::shared_ptr core, const QJsonObject& obj) { - INT32_PEAK(_list._bytes_offset); + INT32_PEAK(_list._bytes_offset, obj); QString bind_unit_name = ""; QString bind_size_provider_name = ""; - STRING_PEAK(bind_unit_name); - STRING_PEAK(bind_size_provider_name); - this->_list._bind_size_v = core->sizeProviders()[bind_size_provider_name]; - this->_list._bind_unit = core->extactors()[bind_unit_name]; + STRING_PEAK(bind_unit_name, obj); + STRING_PEAK(bind_size_provider_name, obj); + auto xdev = core->sizeProviderList()[bind_size_provider_name]->newDefault(); + this->_list._bind_size_v = std::dynamic_pointer_cast(xdev); + xdev = core->extractUnitList()[bind_unit_name]->newDefault(); + this->_list._bind_unit = std::dynamic_pointer_cast(xdev); QString bind_provider_expr = ""; - STRING_SAVE(bind_provider_expr); + STRING_SAVE(bind_provider_expr, obj); this->_list._bind_size_v->setExpression(bind_provider_expr); + + QJsonObject unit_obj; + QJsonObject size_provider_obj; + OBJECT_PEAK(unit_obj, obj); + OBJECT_PEAK(size_provider_obj, obj); + + this->_list._bind_size_v->loadFrom(core, size_provider_obj); + this->_list._bind_unit->loadFrom(core, unit_obj); } +#include void BytesAsList::saveTo(QJsonObject& obj) const { - INT32_SAVE(_list._bytes_offset); + INT32_SAVE(_list._bytes_offset, obj); QString bind_unit_name = ""; - if (this->_list._bind_unit) + QJsonObject unit_obj; + if (this->_list._bind_unit) { bind_unit_name = this->_list._bind_unit->name(); - STRING_SAVE(bind_unit_name); + this->_list._bind_unit->saveTo(unit_obj); + } + STRING_SAVE(bind_unit_name, obj); + OBJECT_SAVE(unit_obj, obj); QString bind_size_provider_name = ""; QString bind_provider_expr = ""; + QJsonObject size_provider_obj; if (this->_list._bind_size_v) { bind_provider_expr = this->_list._bind_size_v->expression(); bind_size_provider_name = this->_list._bind_size_v->name(); + this->_list._bind_size_v->saveTo(size_provider_obj); } - STRING_SAVE(bind_size_provider_name); - STRING_SAVE(bind_provider_expr); + STRING_SAVE(bind_size_provider_name, obj); + STRING_SAVE(bind_provider_expr, obj); + OBJECT_SAVE(size_provider_obj, obj); } QVariant BytesAsList::parse(const QByteArray& bytes) const @@ -437,14 +459,47 @@ QVariant BytesAsUnion::parse(const QByteArray& bytes) const void BytesAsUnion::loadFrom( std::shared_ptr core, const QJsonObject& obj) { - INT32_PEAK(_union.byte_count); - INT32_PEAK(_union.byte_offset); + INT32_PEAK(_union.byte_count, obj); + INT32_PEAK(_union.byte_offset, obj); + + QJsonArray array; + ARRAY_PEAK(array, obj); + this->_union._rule_list.clear(); + for (auto index = 0; index < array.size(); ++index) { + auto rule_obj = array.at(index); + + QString match_name; + STRING_PEAK(match_name, rule_obj); + QJsonObject match_obj; + OBJECT_PEAK(match_obj, rule_obj); + + auto match = core->ruleMatchList()[match_name]; + auto nmatch = match->newDefault(); + nmatch->loadFrom(core, match_obj); + + this->_union._rule_list.append( + std::dynamic_pointer_cast(nmatch)); + } } void BytesAsUnion::saveTo(QJsonObject& obj) const { - INT32_SAVE(_union.byte_count); - INT32_SAVE(_union.byte_offset); + INT32_SAVE(_union.byte_count, obj); + INT32_SAVE(_union.byte_offset, obj); + + QJsonArray array; + for (auto insr : this->_union._rule_list) { + QJsonObject rule_obj; + auto match_name = insr->name(); + STRING_SAVE(match_name, rule_obj); + + QJsonObject match_obj; + insr->saveTo(match_obj); + OBJECT_SAVE(match_obj, rule_obj); + + array.append(rule_obj); + } + ARRAY_SAVE(array, obj); } std::shared_ptr BytesAsUnion::newDefault() const @@ -479,3 +534,79 @@ bool BytesAsUnion::setOffsetSpan(int value) this->_union.byte_offset = value; return true; } + +QString BytesAsSubRule::name() const +{ + return NAME(BytesAsSubRule); +} + +DataType BytesAsSubRule::outType() const +{ + return DataType::SUB_RULE; +} + +bool BytesAsSubRule::setOffsetSpan(int bytes) +{ + this->_rules._byte_offset = bytes; + return true; +} + +int BytesAsSubRule::offsetSpan() const +{ + return this->_rules._byte_offset; +} + +int BytesAsSubRule::countWithin() const +{ + return this->_rules._byte_count; +} + +QVariant BytesAsSubRule::parse(const QByteArray& bytes) const +{ + throw std::logic_error("The method or operation is not implemented."); +} + +void BytesAsSubRule::loadFrom(std::shared_ptr core, const QJsonObject& obj) +{ + INT32_PEAK(_rules._byte_count, obj); + INT32_PEAK(_rules._byte_offset, obj); + + QJsonArray array; + ARRAY_SAVE(array, obj); + + for (auto index = 0; index < array.size(); ++index) { + auto rule_obj = array.at(index); + QString match_name; + QJsonObject match_obj; + STRING_PEAK(match_name, rule_obj); + OBJECT_PEAK(match_obj, rule_obj); + + auto xdev = core->extractUnitList()[match_name]->newDefault(); + xdev->loadFrom(core, match_obj); + _rules._sub_rules.append(std::dynamic_pointer_cast(xdev)); + } +} + +void BytesAsSubRule::saveTo(QJsonObject& obj) const +{ + INT32_SAVE(_rules._byte_count, obj); + INT32_SAVE(_rules._byte_offset, obj); + + QJsonArray array; + for (auto info : _rules._sub_rules) { + QJsonObject rule_obj, match_obj; + + QString match_name = info->name(); + STRING_SAVE(match_name, rule_obj); + info->saveTo(match_obj); + OBJECT_SAVE(match_obj, rule_obj); + + array.append(rule_obj); + } + ARRAY_SAVE(array, obj); +} + +std::shared_ptr BytesAsSubRule::newDefault() const +{ + return std::make_shared(); +} diff --git a/TranslateUI/extract_basic.h b/TranslateUI/extract_basic.h index 8ace874..b3a8afc 100644 --- a/TranslateUI/extract_basic.h +++ b/TranslateUI/extract_basic.h @@ -48,7 +48,7 @@ public: /// /// ³ß´ç½âÎöÆ÷ /// -class SizeProvider { +class SizeProvider : public Serializable { public: virtual QString name() const = 0; /// @@ -64,10 +64,11 @@ public: /// /// ¹æÔòÆ¥ÅäÆ÷ /// -class RuleMatch { +class RuleMatch : public Serializable { public: virtual QString name() const = 0; virtual std::shared_ptr bindRule() const = 0; + virtual void bindRule(std::shared_ptr rule) = 0; virtual bool checkpass(const QByteArray& buffer) const = 0; }; @@ -262,6 +263,31 @@ namespace extract { std::shared_ptr newDefault() const override; }; + + + class BytesAsSubRule : public ExtractUnit { + public: + struct __Private { + int _byte_offset = 0, _byte_count = 1; + QList> _sub_rules; + }_rules; + + + QString name() const override; + DataType outType() const override; + bool setOffsetSpan(int bytes) override; + int offsetSpan() const override; + int countWithin() const override; + std::shared_ptr newDefault() const override; + + + QVariant parse(const QByteArray& bytes) const override; + + + void loadFrom(std::shared_ptr core, const QJsonObject& obj) override; + void saveTo(QJsonObject& obj) const override; + + }; }