codeboss
/
QBinaryTranslate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update

This commit is contained in:
codeboss 2025-08-05 18:30:24 +08:00
parent 3551d68cdd
commit 68b3b86fb9
7 changed files with 107 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
TranslateUI/SequenceView.cpp
View File

@ -37,21 +37,21 @@ void IntDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewIt
void SequenceRulesView::currentRuleRefresh(const QModelIndex& idx) void SequenceRulesView::currentRuleRefresh(const QModelIndex& idx)
{ {
auto rule_insv = _view._ruleset->_rules[idx.row()]; auto rule_insv = _view._ruleset->_bind[idx.row()];
auto offset_index = idx.sibling(idx.row(), 1); auto offset_index = idx.sibling(idx.row(), 1);
auto offset_number = offset_index.data(Qt::DisplayRole).toInt(); auto offset_number = offset_index.data(Qt::DisplayRole).toInt();
rule_insv.second->setOffsetSpan(offset_number); rule_insv.second->setOffsetSpan(offset_number);
auto count_index = idx.sibling(idx.row(), 3); auto count_index = idx.sibling(idx.row(), 3);
_view._sequence_model->setData(offset_index, rule_insv.second->offsetSpan(), Qt::EditRole); _view._seqs_model->setData(offset_index, rule_insv.second->offsetSpan(), Qt::EditRole);
_view._sequence_model->setData(count_index, rule_insv.second->countWithin(), Qt::EditRole); _view._seqs_model->setData(count_index, rule_insv.second->countWithin(), Qt::EditRole);
auto param_index = idx.sibling(idx.row(), 4); auto param_index = idx.sibling(idx.row(), 4);
QJsonObject obj; QJsonObject obj;
rule_insv.second->saveTo(obj); rule_insv.second->saveTo(obj);
auto bytes = QJsonDocument(obj).toJson(QJsonDocument::Compact); auto bytes = QJsonDocument(obj).toJson(QJsonDocument::Compact);
_view._sequence_model->setData(param_index, QString::fromUtf8(bytes)); _view._seqs_model->setData(param_index, QString::fromUtf8(bytes));
this->resizeColumnsToContents(); this->resizeColumnsToContents();
} }
@ -66,7 +66,7 @@ void SequenceRulesView::peersRuleChanged(const QModelIndex& idx)
auto rule_nm = _view.base->extractUnitList()[rule_name]; auto rule_nm = _view.base->extractUnitList()[rule_name];
auto new_inst = std::dynamic_pointer_cast<ExtractUnit>(rule_nm->newDefault()); auto new_inst = std::dynamic_pointer_cast<ExtractUnit>(rule_nm->newDefault());
_view._ruleset->_rules.replace(idx.row(), std::make_pair(field_name, new_inst)); _view._ruleset->_bind.replace(idx.row(), std::make_pair(field_name, new_inst));
// ¶ÔListUnitÖ´ÐÐÌØÊâ³õʼ»¯²½Öè // ¶ÔListUnitÖ´ÐÐÌØÊâ³õʼ»¯²½Öè
if (typeid(*new_inst.get()) == typeid(BytesAsList)) { if (typeid(*new_inst.get()) == typeid(BytesAsList)) {
@ -83,16 +83,25 @@ void SequenceRulesView::peersRuleChanged(const QModelIndex& idx)
currentRuleRefresh(idx); currentRuleRefresh(idx);
} }
void SequenceRulesView::showEvent(QShowEvent* e)
{
QTableView::showEvent(e);
membersPresent(this->_view._ruleset, this->_view._seqs_model);
}
#include <QItemSelectionModel> #include <QItemSelectionModel>
SequenceRulesView::SequenceRulesView(std::shared_ptr<extract::BytesAsRuleSet> rule_set, QWidget* p /*= nullptr*/) SequenceRulesView::SequenceRulesView(
std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::BytesAsRuleSet> rule_set, QWidget* p /*= nullptr*/)
:QTableView(p) :QTableView(p)
{ {
_view._ruleset = rule_set; _view._ruleset = rule_set;
_view._sequence_model = new QStandardItemModel(); _view._seqs_model = new QStandardItemModel();
_view.base = std::make_shared<TranslateBasic>(); _view.base = std::make_shared<TranslateBasic>();
this->setModel(_view._sequence_model); this->setModel(_view._seqs_model);
_view._sequence_model->setHorizontalHeaderLabels(QStringList() _view._seqs_model->setHorizontalHeaderLabels(QStringList()
<< tr(u8"Field Name") << tr(u8"Bytes Offset") << tr(u8"Translate Rule") << tr(u8"Field Name") << tr(u8"Bytes Offset") << tr(u8"Translate Rule")
<< tr(u8"Bytes Count") << tr(u8"Arguments")); << tr(u8"Bytes Count") << tr(u8"Arguments"));
@ -110,7 +119,7 @@ SequenceRulesView::SequenceRulesView(std::shared_ptr<extract::BytesAsRuleSet> ru
if (!curr.isValid()) if (!curr.isValid())
return; return;
emit this->currentRuleChanged(_view._ruleset->_rules[curr.row()].second, curr); emit this->currentRuleChanged(_view._ruleset->_bind[curr.row()].second, curr);
}); });
} }
@ -125,31 +134,15 @@ void SequenceRulesView::customTranslateRuleEdit(const QPoint& pos)
void SequenceRulesView::addTranslateUnit() void SequenceRulesView::addTranslateUnit()
{ {
auto row_cnt = this->_view._sequence_model->rowCount();
QList<QStandardItem*> new_row;
new_row << new QStandardItem(QString(u8"rule_%1").arg(row_cnt));
new_row << new QStandardItem(u8"0");
new_row << new QStandardItem(_view.base->defaultExtractUnit()->name());
new_row << new QStandardItem(u8"1");
new_row.last()->setEditable(false);
auto curr_rule = _view.base->defaultExtractUnit()->newDefault(); auto curr_rule = _view.base->defaultExtractUnit()->newDefault();
this->_view._ruleset->_rules.append( this->_view._ruleset->_bind.append(
new_row.first()->text(), std::static_pointer_cast<ExtractUnit>(curr_rule)); QString(u8"rule_%1").arg(_view._ruleset->_bind.sub_units.size()),
std::static_pointer_cast<ExtractUnit>(curr_rule));
auto hex_rule = std::static_pointer_cast<BytesAsHex>(curr_rule); auto hex_rule = std::static_pointer_cast<BytesAsHex>(curr_rule);
hex_rule->setCountWithin(1); hex_rule->setCountWithin(1);
QJsonObject obj; membersPresent(this->_view._ruleset, this->_view._seqs_model);
curr_rule->saveTo(obj);
auto bytes = QJsonDocument(obj).toJson(QJsonDocument::Compact);
auto json_doc = QString::fromUtf8(bytes);
new_row << new QStandardItem(json_doc);
new_row.last()->setEditable(false);
this->_view._sequence_model->appendRow(new_row);
this->resizeColumnsToContents();
} }
void SequenceRulesView::removeTranslateUnit() void SequenceRulesView::removeTranslateUnit()
@ -158,10 +151,37 @@ void SequenceRulesView::removeTranslateUnit()
if (!idx_curr.isValid()) if (!idx_curr.isValid())
return; return;
_view._ruleset->_rules.removeAt(idx_curr.row()); _view._ruleset->_bind.removeAt(idx_curr.row());
_view._sequence_model->removeRow(idx_curr.row()); _view._seqs_model->removeRow(idx_curr.row());
} }
void SequenceRulesView::membersPresent(std::shared_ptr<extract::BytesAsRuleSet> ruleset, QStandardItemModel* model)
{
model->removeRows(0, model->rowCount());
auto units = ruleset->_bind.sub_units;
for (auto uidx = 0; uidx < units.size(); ++uidx) {
auto u_pair = units.at(uidx);
QList<QStandardItem*> new_row;
new_row << new QStandardItem(u_pair.first);
new_row << new QStandardItem(QString("%1").arg(u_pair.second->offsetSpan()));
new_row << new QStandardItem(_view.base->defaultExtractUnit()->name());
new_row << new QStandardItem(QString("%1").arg(u_pair.second->countWithin()));
new_row.last()->setEditable(false);
QJsonObject obj;
u_pair.second->saveTo(obj);
auto bytes = QJsonDocument(obj).toJson(QJsonDocument::Compact);
auto json_doc = QString::fromUtf8(bytes);
new_row << new QStandardItem(json_doc);
new_row.last()->setEditable(false);
this->_view._seqs_model->appendRow(new_row);
}
this->resizeColumnsToContents();
}
RuleSelectDelegate::RuleSelectDelegate(std::shared_ptr<TranslateBasic> ins) RuleSelectDelegate::RuleSelectDelegate(std::shared_ptr<TranslateBasic> ins)
:_kernel(ins) { :_kernel(ins) {

13
TranslateUI/SequenceView.h
View File

@ -57,9 +57,9 @@ public:
/// </summary> /// </summary>
class SequenceRulesView : public QTableView { class SequenceRulesView : public QTableView {
Q_OBJECT Q_OBJECT
public: private:
struct __Private { struct __Private {
QStandardItemModel* _sequence_model; QStandardItemModel* _seqs_model;
std::shared_ptr<TranslateBasic> base = nullptr; std::shared_ptr<TranslateBasic> base = nullptr;
std::shared_ptr<extract::BytesAsRuleSet> _ruleset = nullptr; std::shared_ptr<extract::BytesAsRuleSet> _ruleset = nullptr;
} _view; } _view;
@ -71,11 +71,18 @@ public:
void currentRuleRefresh(const QModelIndex& idx); void currentRuleRefresh(const QModelIndex& idx);
void peersRuleChanged(const QModelIndex& idx_rule); void peersRuleChanged(const QModelIndex& idx_rule);
protected:
void showEvent(QShowEvent* e) override;
public: public:
SequenceRulesView(std::shared_ptr<extract::BytesAsRuleSet> rule_set, QWidget* p = nullptr); SequenceRulesView(
std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::BytesAsRuleSet> rule_set, QWidget* p = nullptr);
void customTranslateRuleEdit(const QPoint& pos); void customTranslateRuleEdit(const QPoint& pos);
void addTranslateUnit(); void addTranslateUnit();
void removeTranslateUnit(); void removeTranslateUnit();
void membersPresent(std::shared_ptr<extract::BytesAsRuleSet> _bind, QStandardItemModel* model);
}; };

11
TranslateUI/StructuralRuleView.cpp
View File

@ -9,9 +9,10 @@
#include "TranslateBasic.h" #include "TranslateBasic.h"
StructuralRuleView::StructuralRuleView( StructuralRuleView::StructuralRuleView(
std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::BytesAsRuleSet> inst_r, QWidget* p /*= nullptr*/) std::shared_ptr<extract::BytesAsRuleSet> inst_r, QWidget* p /*= nullptr*/)
: QWidget(p), : QWidget(p), _rule_base(inst_r),
_sequence_view(new SequenceRulesView(inst_r, this)), _sequence_view(new SequenceRulesView(base, inst_r, this)),
_configs_stack(new QStackedWidget(this)) _configs_stack(new QStackedWidget(this))
{ {
this->_current_fields_cache = std::make_shared<FieldManagerLayer>("", nullptr); this->_current_fields_cache = std::make_shared<FieldManagerLayer>("", nullptr);
@ -30,7 +31,7 @@ StructuralRuleView::StructuralRuleView(
_configs_stack->addWidget(encode_config); _configs_stack->addWidget(encode_config);
auto combine_config = new BitCombineConfiguration(this); auto combine_config = new BitCombineConfiguration(this);
_configs_stack->addWidget(combine_config); _configs_stack->addWidget(combine_config);
auto list_config = new ListUnitConfiguration(this->_sequence_view->_view.base, this); auto list_config = new ListUnitConfiguration(base, this);
_configs_stack->addWidget(list_config); _configs_stack->addWidget(list_config);
connect(count_span, &CountWithinConfiguration::currentRuleChanged, connect(count_span, &CountWithinConfiguration::currentRuleChanged,
@ -76,12 +77,12 @@ void StructuralRuleView::cacheRefresh(const QModelIndex& curr, ListUnitConfigura
return; return;
this->_current_fields_cache->clear(); this->_current_fields_cache->clear();
this->_sequence_view->_view._ruleset->registSubField(this->_current_fields_cache); this->_rule_base->registSubField(this->_current_fields_cache);
auto field_idx = curr.sibling(curr.row(), 0); auto field_idx = curr.sibling(curr.row(), 0);
this->_current_fields_cache->bindCurrent(field_idx.data(Qt::DisplayRole).toString()); this->_current_fields_cache->bindCurrent(field_idx.data(Qt::DisplayRole).toString());
auto ins = this->_sequence_view->_view._ruleset->_rules[curr.row()]; auto ins = this->_rule_base->_bind[curr.row()];
auto conv = std::dynamic_pointer_cast<extract::BytesAsList>(ins.second); auto conv = std::dynamic_pointer_cast<extract::BytesAsList>(ins.second);
if (conv) { if (conv) {
t->currentRuleAccept(conv, curr, this->_current_fields_cache); t->currentRuleAccept(conv, curr, this->_current_fields_cache);

6
TranslateUI/StructuralRuleView.h
View File

@ -119,11 +119,13 @@ private:
SequenceRulesView* const _sequence_view; SequenceRulesView* const _sequence_view;
QStackedWidget* const _configs_stack; QStackedWidget* const _configs_stack;
std::shared_ptr<extract::BytesAsRuleSet> _rule_base;
std::shared_ptr<FieldManagerLayer> _current_fields_cache = nullptr; std::shared_ptr<FieldManagerLayer> _current_fields_cache = nullptr;
public: public:
StructuralRuleView(std::shared_ptr<extract::BytesAsRuleSet> inst_r, QWidget* p = nullptr); StructuralRuleView(std::shared_ptr<TranslateBasic> base,
std::shared_ptr<extract::BytesAsRuleSet> inst_r, QWidget* p = nullptr);
void cacheRefresh(const QModelIndex &curr, ListUnitConfiguration* t); void cacheRefresh(const QModelIndex& curr, ListUnitConfiguration* t);
}; };

22
TranslateUI/TranslateUI.cpp
View File

@ -24,8 +24,8 @@ TranslateUI::TranslateUI(QWidget* parent)
_ruleset_navi->setContextMenuPolicy(Qt::CustomContextMenu); _ruleset_navi->setContextMenuPolicy(Qt::CustomContextMenu);
connect(_ruleset_navi, &QWidget::customContextMenuRequested, [=](const QPoint& pos) { connect(_ruleset_navi, &QWidget::customContextMenuRequested, [=](const QPoint& pos) {
QMenu m; QMenu m;
m.addAction(u8"添加Rule", this, &TranslateUI::addCustomRule); m.addAction(u8"Add Rule", this, &TranslateUI::addCustomRule);
m.addAction(u8"打开ExtractView", this, &TranslateUI::openExtractView); m.addAction(u8"Open ExtractView", this, &TranslateUI::openExtractView);
m.exec(this->mapToGlobal(pos)); m.exec(this->mapToGlobal(pos));
}); });
@ -37,9 +37,10 @@ TranslateUI::TranslateUI(QWidget* parent)
connect(_tab_widget, &QTabWidget::tabCloseRequested, _core._view_mgr, &ViewManager::closeAt); connect(_tab_widget, &QTabWidget::tabCloseRequested, _core._view_mgr, &ViewManager::closeAt);
connect(_core._view_mgr, &ViewManager::appendRequest, _tab_widget, QOverload<QWidget*, const QString&>::of(&QTabWidget::addTab)); connect(_core._view_mgr, &ViewManager::appendRequest, _tab_widget, QOverload<QWidget*, const QString&>::of(&QTabWidget::addTab));
connect(_core._view_mgr, &ViewManager::removeRequest, _tab_widget, &QTabWidget::removeTab); connect(_core._view_mgr, &ViewManager::removeRequest, _tab_widget, &QTabWidget::removeTab);
connect(_core._view_mgr, &ViewManager::activeRequest, _tab_widget, &QTabWidget::setTabText); connect(_core._view_mgr, &ViewManager::activeRequest, _tab_widget, &QTabWidget::setCurrentIndex);
this->present_solution_customs(_core._translate_core, _solution_model); this->present_solution_customs(_core._translate_core, _solution_model);
splitter->setStretchFactor(1, 1);
} }
TranslateUI::~TranslateUI() TranslateUI::~TranslateUI()
@ -49,13 +50,13 @@ TranslateUI::~TranslateUI()
#include <QMessageBox> #include <QMessageBox>
void TranslateUI::addCustomRule() void TranslateUI::addCustomRule()
{ {
auto name = QInputDialog::getText(this, u8"输入Rule名称", "Rule:"); auto name = QInputDialog::getText(this, u8"Please Enter Rule Name", "Rule:");
if (name == "") if (name == "")
return; return;
auto names = this->_core._translate_core->customRules().keys(); auto names = this->_core._translate_core->customRules().keys();
if (names.contains(name)) { if (names.contains(name)) {
QMessageBox::critical(this, "输入校验", "RuleName不能重复"); QMessageBox::critical(this, u8"输入校验", u8"RuleName不能重复");
return; return;
} }
@ -98,22 +99,23 @@ void ViewManager::open(const QString& rule_name, ViewType v_type, QWidget* p)
{ {
for (auto vidx = 0; vidx < content_pages.size(); vidx++) { for (auto vidx = 0; vidx < content_pages.size(); vidx++) {
auto v = content_pages.at(vidx); auto v = content_pages.at(vidx);
if (std::get<0>(v)->name() == rule_name && std::get<2>(v) == v_type) { if (std::get<0>(v)->customName() == rule_name && std::get<2>(v) == v_type) {
emit this->activeRequest(vidx, rule_name); emit this->activeRequest(vidx, rule_name);
return; return;
} }
} }
assert("指定rule_name必须合法" && _translate_core->customRules().contains(rule_name)); assert(u8"指定rule_name必须合法" && _translate_core->customRules().contains(rule_name));
auto appoint = _translate_core->customRules()[rule_name]; auto appoint = _translate_core->customRules()[rule_name];
auto present = new StructuralRuleView(appoint, p); auto present = new StructuralRuleView(_translate_core, appoint, p);
content_pages << std::make_tuple(appoint, present, v_type); content_pages << std::make_tuple(appoint, present, v_type);
emit this->appendRequest(present, rule_name); emit this->appendRequest(present, rule_name);
emit this->activeRequest(content_pages.size() - 1, rule_name);
} }
void ViewManager::closeAt(int index) void ViewManager::closeAt(int index)
{ {
assert("index必须有效" && (index < content_pages.size())); assert(u8"index必须有效" && (index < content_pages.size()));
emit this->removeRequest(index); emit this->removeRequest(index);
auto current = this->content_pages.at(index); auto current = this->content_pages.at(index);
@ -131,7 +133,7 @@ void ViewManager::active(const QString& rule_name, ViewType v_type)
} }
} }
assert("RuleName和V_Type组合必须有效" && 0); assert(u8"RuleName和V_Type组合必须有效" && 0);
} }
void ViewManager::purge(const QString& rule_name) void ViewManager::purge(const QString& rule_name)

42
TranslateUI/extract_basic.cpp
View File

@ -559,8 +559,8 @@ void BytesAsUnion::registSubField(std::shared_ptr<ScopeFieldsSetter> inst)
void BytesAsRuleSet::registSubField(std::shared_ptr<ScopeFieldsSetter> inst) void BytesAsRuleSet::registSubField(std::shared_ptr<ScopeFieldsSetter> inst)
{ {
for (auto rl_key : this->_rules.fieldNames()){ for (auto rl_key : this->_bind.fieldNames()){
auto rlinst = this->_rules[rl_key]; auto rlinst = this->_bind[rl_key];
inst->setField(rl_key, rlinst->outType()); inst->setField(rl_key, rlinst->outType());
auto layer = std::make_shared<FieldManagerLayer>(rl_key, inst); auto layer = std::make_shared<FieldManagerLayer>(rl_key, inst);
rlinst->registSubField(layer); rlinst->registSubField(layer);
@ -570,11 +570,11 @@ void BytesAsRuleSet::registSubField(std::shared_ptr<ScopeFieldsSetter> inst)
void BytesAsRuleSet::parse(const QByteArray& bytes, std::shared_ptr<DataAccessContext> out) const void BytesAsRuleSet::parse(const QByteArray& bytes, std::shared_ptr<DataAccessContext> out) const
{ {
auto bufx = bytes; auto bufx = bytes;
for (auto keym : this->_rules.fieldNames()) { for (auto keym : this->_bind.fieldNames()) {
auto rule_context = std::make_shared<ValueAccess>(); auto rule_context = std::make_shared<ValueAccess>();
rule_context->init(keym, out); rule_context->init(keym, out);
auto rule = this->_rules[keym]; auto rule = this->_bind[keym];
bufx = bufx.mid(rule->offsetSpan()); bufx = bufx.mid(rule->offsetSpan());
auto count = rule->countWithin(); auto count = rule->countWithin();
auto secx = bufx.mid(0, count); auto secx = bufx.mid(0, count);
@ -595,24 +595,24 @@ DataType BytesAsRuleSet::outType() const
bool BytesAsRuleSet::setOffsetSpan(int bytes) bool BytesAsRuleSet::setOffsetSpan(int bytes)
{ {
this->_rules._byte_offset = bytes; this->_bind._byte_offset = bytes;
return true; return true;
} }
int BytesAsRuleSet::offsetSpan() const int BytesAsRuleSet::offsetSpan() const
{ {
return this->_rules._byte_offset; return this->_bind._byte_offset;
} }
int BytesAsRuleSet::countWithin() const int BytesAsRuleSet::countWithin() const
{ {
return this->_rules._byte_count; return this->_bind._byte_count;
} }
void BytesAsRuleSet::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonObject& obj) void BytesAsRuleSet::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonObject& obj)
{ {
INT32_PEAK(_rules._byte_count, obj); INT32_PEAK(_bind._byte_count, obj);
INT32_PEAK(_rules._byte_offset, obj); INT32_PEAK(_bind._byte_offset, obj);
QJsonArray array; QJsonArray array;
ARRAY_SAVE(array, obj); ARRAY_SAVE(array, obj);
@ -627,17 +627,17 @@ void BytesAsRuleSet::loadFrom(std::shared_ptr<TranslateBasic> core, const QJsonO
auto xdev = core->extractUnitList()[match_name]->newDefault(); auto xdev = core->extractUnitList()[match_name]->newDefault();
xdev->loadFrom(core, match_obj); xdev->loadFrom(core, match_obj);
_rules._sub_rules << std::make_pair(key, std::dynamic_pointer_cast<ExtractUnit>(xdev)); _bind.sub_units << std::make_pair(key, std::dynamic_pointer_cast<ExtractUnit>(xdev));
} }
} }
void BytesAsRuleSet::saveTo(QJsonObject& obj) const void BytesAsRuleSet::saveTo(QJsonObject& obj) const
{ {
INT32_SAVE(_rules._byte_count, obj); INT32_SAVE(_bind._byte_count, obj);
INT32_SAVE(_rules._byte_offset, obj); INT32_SAVE(_bind._byte_offset, obj);
QJsonArray array; QJsonArray array;
for (auto pairk : _rules._sub_rules) { for (auto pairk : _bind.sub_units) {
QJsonObject rule_obj, match_obj; QJsonObject rule_obj, match_obj;
auto key = pairk.first; auto key = pairk.first;
@ -660,29 +660,29 @@ std::shared_ptr<Serializable> BytesAsRuleSet::newDefault() const
std::pair<QString, std::shared_ptr<ExtractUnit>> BytesAsRuleSet::__Private::operator[](int index) const std::pair<QString, std::shared_ptr<ExtractUnit>> BytesAsRuleSet::__Private::operator[](int index) const
{ {
return this->_sub_rules[index]; return this->sub_units[index];
} }
void BytesAsRuleSet::__Private::replace(int index, std::pair<QString, std::shared_ptr<ExtractUnit>> inst) void BytesAsRuleSet::__Private::replace(int index, std::pair<QString, std::shared_ptr<ExtractUnit>> inst)
{ {
this->_sub_rules.replace(index, inst); this->sub_units.replace(index, inst);
} }
extract::BytesAsRuleSet::__Private& BytesAsRuleSet::__Private::append(const QString& nm, std::shared_ptr<ExtractUnit> u) extract::BytesAsRuleSet::__Private& BytesAsRuleSet::__Private::append(const QString& nm, std::shared_ptr<ExtractUnit> u)
{ {
this->_sub_rules.append(std::make_pair(nm, u)); this->sub_units.append(std::make_pair(nm, u));
return *this; return *this;
} }
void BytesAsRuleSet::__Private::removeAt(int index) void BytesAsRuleSet::__Private::removeAt(int index)
{ {
this->_sub_rules.removeAt(index); this->sub_units.removeAt(index);
} }
QList<QString> BytesAsRuleSet::__Private::fieldNames() const QList<QString> BytesAsRuleSet::__Private::fieldNames() const
{ {
QList<QString> fields_store; QList<QString> fields_store;
for (auto fpair : this->_sub_rules) { for (auto fpair : this->sub_units) {
fields_store << fpair.first; fields_store << fpair.first;
} }
return fields_store;; return fields_store;;
@ -690,7 +690,7 @@ QList<QString> BytesAsRuleSet::__Private::fieldNames() const
std::shared_ptr<ExtractUnit> BytesAsRuleSet::__Private::operator[](const QString& field) const std::shared_ptr<ExtractUnit> BytesAsRuleSet::__Private::operator[](const QString& field) const
{ {
for (auto pair : this->_sub_rules) { for (auto pair : this->sub_units) {
if(pair.first == field) if(pair.first == field)
return pair.second; return pair.second;
} }
@ -700,10 +700,10 @@ std::shared_ptr<ExtractUnit> BytesAsRuleSet::__Private::operator[](const QString
void BytesAsRuleSet::setCustomName(const QString& name) void BytesAsRuleSet::setCustomName(const QString& name)
{ {
_rules._name_store = name; _bind._name_store = name;
} }
QString BytesAsRuleSet::customName() const QString BytesAsRuleSet::customName() const
{ {
return _rules._name_store; return _bind._name_store;
} }

4
TranslateUI/extract_basic.h
View File

@ -256,7 +256,7 @@ namespace extract {
struct __Private { struct __Private {
int _byte_offset = 0, _byte_count = 1; int _byte_offset = 0, _byte_count = 1;
QString _name_store; QString _name_store;
QList<std::pair<QString, std::shared_ptr<ExtractUnit>>> _sub_rules; QList<std::pair<QString, std::shared_ptr<ExtractUnit>>> sub_units;
QList<QString> fieldNames() const; QList<QString> fieldNames() const;
std::shared_ptr<ExtractUnit> operator[](const QString &field) const; std::shared_ptr<ExtractUnit> operator[](const QString &field) const;
@ -266,7 +266,7 @@ namespace extract {
void replace(int index, std::pair<QString, std::shared_ptr<ExtractUnit>> inst); void replace(int index, std::pair<QString, std::shared_ptr<ExtractUnit>> inst);
void removeAt(int index); void removeAt(int index);
__Private& append(const QString& nm, std::shared_ptr<ExtractUnit> u); __Private& append(const QString& nm, std::shared_ptr<ExtractUnit> u);
}_rules; }_bind;
void setCustomName(const QString& name); void setCustomName(const QString& name);
QString customName() const; QString customName() const;