Initial commit
This commit is contained in:
user
@@ -0,0 +1,564 @@
|
||||
#include "demonstrationWidget.h"
|
||||
|
||||
inline void DemonstrationWidget::TableInformation::clear() {
|
||||
for (size_t *value :
|
||||
{&m_maxCollision, &m_numberOfSuccesses, &m_numberOfFailures}) {
|
||||
*value = 0;
|
||||
}
|
||||
for (double *value : {&m_lastCoefficient, &m_maxCoefficient}) {
|
||||
*value = 0;
|
||||
}
|
||||
for (auto *series : {m_pSeriesNumberOfCollisions}) {
|
||||
series->removePoints(0, series->count());
|
||||
}
|
||||
m_pSeriesNumberOfCollisions->append(0, 0);
|
||||
|
||||
m_lastCoord = {0, 0};
|
||||
m_lastValue = {'\0', '\0', '\0', '\0', '\0'};
|
||||
m_lastInsertion = false;
|
||||
}
|
||||
|
||||
DemonstrationWidget::DemonstrationWidget(QWidget *pWidget)
|
||||
: QWidget(pWidget),
|
||||
m_pChartCollisionsView(new QChartView(new QChart, this)),
|
||||
m_pStandardModel(nullptr), m_stop(false), m_pFunction(nullptr),
|
||||
m_complicatedFunction(nullptr), m_pAlgorithm(nullptr),
|
||||
m_alphabetPower(endChar - firstChar + 1), m_pTable(nullptr),
|
||||
m_tableInformation(new QLineSeries(m_pChartCollisionsView->chart())) {
|
||||
setupUi(dynamic_cast<QWidget *>(this));
|
||||
|
||||
m_tableView->horizontalHeader()->setSectionResizeMode(
|
||||
QHeaderView::ResizeToContents);
|
||||
QGridLayout *gridLayout = new QGridLayout;
|
||||
|
||||
/*
|
||||
* Сhart
|
||||
*/
|
||||
|
||||
auto *axisX = new QValueAxis();
|
||||
auto *axisY = new QValueAxis();
|
||||
axisX->setTickCount(20);
|
||||
axisY->setTickCount(10);
|
||||
axisX->setRange(1, 2);
|
||||
axisY->setRange(0, 1);
|
||||
|
||||
QChart *chartCollision = m_pChartCollisionsView->chart();
|
||||
chartCollision->setTitle("Graph of collision changes");
|
||||
chartCollision->legend()->hide();
|
||||
chartCollision->addAxis(axisX, Qt::AlignBottom);
|
||||
chartCollision->addAxis(axisY, Qt::AlignLeft);
|
||||
chartCollision->addSeries(m_tableInformation.m_pSeriesNumberOfCollisions);
|
||||
m_tableInformation.m_pSeriesNumberOfCollisions->attachAxis(axisX);
|
||||
m_tableInformation.m_pSeriesNumberOfCollisions->attachAxis(axisY);
|
||||
|
||||
/*
|
||||
* View(-s)
|
||||
*/
|
||||
|
||||
m_pChartCollisionsView->installEventFilter(this);
|
||||
m_pChartCollisionsView->setRubberBand(QChartView::RectangleRubberBand);
|
||||
m_pChartCollisionsView->setRenderHint(QPainter::Antialiasing);
|
||||
m_pChartCollisionsView->setMinimumHeight(m_tableView->minimumHeight());
|
||||
m_pChartCollisionsView->setMinimumWidth(m_tableView->minimumWidth());
|
||||
|
||||
/*
|
||||
* Splitter
|
||||
*/
|
||||
|
||||
QSplitter *splitter = new QSplitter(Qt::Vertical);
|
||||
splitter->addWidget(m_tableView);
|
||||
splitter->addWidget(m_pChartCollisionsView);
|
||||
|
||||
gridLayout->addWidget(splitter, 0, 0, 1, 1);
|
||||
gridLayout->addWidget(m_rightScrollArea, 0, 1, 1, 1);
|
||||
gridLayout->addWidget(m_frmProgressBar, 1, 0, 1, 2);
|
||||
setLayout(gridLayout);
|
||||
|
||||
/*
|
||||
* Validator and HTML theory
|
||||
*/
|
||||
|
||||
m_leFrom->setValidator(new LatinValidator(m_leFrom));
|
||||
m_leInsert->setValidator(new LatinValidator(m_leInsert));
|
||||
|
||||
/*
|
||||
* Signal & slots
|
||||
*/
|
||||
|
||||
connect(m_pbReset, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedReset);
|
||||
connect(m_pbApply, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedApply);
|
||||
connect(m_pbStatistics, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedStatistics);
|
||||
connect(m_pbMakeItems, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedMakeItems);
|
||||
connect(m_pbInsert, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedInsert);
|
||||
connect(m_pbFindFree, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedFindFree);
|
||||
connect(m_pbStop, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedStop);
|
||||
connect(m_pbFocus, &QPushButton::clicked, this,
|
||||
&DemonstrationWidget::slotClickedFocus);
|
||||
|
||||
connect(m_rbFNV1a32bit, &QRadioButton::toggled, this,
|
||||
&DemonstrationWidget::slotUpdateAdditionalInputData);
|
||||
connect(m_rbPseudorandomProbing, &QRadioButton::toggled, this,
|
||||
&DemonstrationWidget::slotUpdateAdditionalInputData);
|
||||
connect(m_rbDoubleHashing, &QRadioButton::toggled, this,
|
||||
&DemonstrationWidget::slotUpdateAdditionalInputData);
|
||||
connect(m_rbChains, &QRadioButton::toggled, this,
|
||||
&DemonstrationWidget::slotUpdateAdditionalInputData);
|
||||
|
||||
/*
|
||||
* GUI
|
||||
*/
|
||||
m_frmProgressBar->hide();
|
||||
m_frmFirstInputData->hide();
|
||||
m_frmSecondInputData->hide();
|
||||
m_gbInputData->hide();
|
||||
}
|
||||
|
||||
/*
|
||||
* Inserting elements
|
||||
*/
|
||||
|
||||
void DemonstrationWidget::successfulInsertion(const table_type *,
|
||||
const value_type &value,
|
||||
std::pair<size_t, size_t> index,
|
||||
size_t numberOfCollisions) {
|
||||
m_tableInformation.m_lastCoord = index;
|
||||
m_tableInformation.m_lastValue = value;
|
||||
m_tableInformation.m_lastInsertion = true;
|
||||
++m_tableInformation.m_numberOfSuccesses;
|
||||
|
||||
m_tableInformation.m_lastCollision = numberOfCollisions;
|
||||
m_tableInformation.m_maxCollision = {numberOfCollisions >
|
||||
m_tableInformation.m_maxCollision
|
||||
? numberOfCollisions
|
||||
: m_tableInformation.m_maxCollision};
|
||||
|
||||
m_tableInformation.m_lastCollision = numberOfCollisions;
|
||||
if (numberOfCollisions > m_tableInformation.m_maxCollision) {
|
||||
m_tableInformation.m_maxCollision = numberOfCollisions;
|
||||
}
|
||||
|
||||
m_tableInformation.m_pSeriesNumberOfCollisions->append(
|
||||
m_tableInformation.m_numberOfSuccesses, numberOfCollisions);
|
||||
|
||||
QModelIndex modelIndex = m_pStandardModel->index(index.first, index.second);
|
||||
if (getCurrentTableType() == TableType::Chain) {
|
||||
updateColumns(index.first);
|
||||
} else {
|
||||
m_pStandardModel->setData(modelIndex, QVariant(toQString(value)));
|
||||
}
|
||||
}
|
||||
|
||||
void DemonstrationWidget::unsuccessfulInsertion(const table_type *,
|
||||
const value_type &value) {
|
||||
m_tableInformation.m_lastValue = value;
|
||||
m_tableInformation.m_lastInsertion = false;
|
||||
++m_tableInformation.m_numberOfFailures;
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::updateColumns(size_t rowIndex) {
|
||||
using namespace BusinessLogic::Hash::Table;
|
||||
|
||||
auto tableRow =
|
||||
dynamic_cast<BusinessLogic::Hash::Table::Chains *>(m_pTable.get())
|
||||
->row(rowIndex);
|
||||
size_t modelColumnCount = m_pStandardModel->columnCount();
|
||||
size_t tableColumnCount = tableRow.size();
|
||||
|
||||
if (modelColumnCount < tableColumnCount) {
|
||||
m_pStandardModel->insertColumns(
|
||||
modelColumnCount,
|
||||
std::max(tableColumnCount - modelColumnCount,
|
||||
static_cast<size_t>(std::ceil(
|
||||
std::sqrt(m_tableInformation.m_lastCoefficient)))));
|
||||
}
|
||||
|
||||
QModelIndex modelIndex;
|
||||
auto iterator = tableRow.begin();
|
||||
for (size_t i = 0, size = tableRow.size(); i < size; ++i, ++iterator) {
|
||||
modelIndex = m_pStandardModel->index(rowIndex, i);
|
||||
m_pStandardModel->setData(modelIndex, QVariant(toQString(*iterator)));
|
||||
}
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::updateCharts() {
|
||||
m_pChartCollisionsView->chart()
|
||||
->axes(Qt::Horizontal)
|
||||
.front()
|
||||
->setRange(1, m_tableInformation.m_numberOfSuccesses);
|
||||
m_pChartCollisionsView->chart()
|
||||
->axes(Qt::Vertical)
|
||||
.front()
|
||||
->setRange(0, m_tableInformation.m_maxCollision);
|
||||
m_pChartCollisionsView->chart()->resetMatrix();
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::updateTableView() {
|
||||
m_tableView->scrollTo(
|
||||
m_pStandardModel->index(m_tableInformation.m_lastCoord.first,
|
||||
m_tableInformation.m_lastCoord.second),
|
||||
QAbstractItemView::PositionAtCenter);
|
||||
m_tableView->repaint();
|
||||
}
|
||||
|
||||
inline DemonstrationWidget::value_type &
|
||||
DemonstrationWidget::next(value_type &value) const {
|
||||
auto rbegin = value.rbegin();
|
||||
auto rend = value.rend();
|
||||
|
||||
for (; rbegin != rend; ++rbegin) {
|
||||
if (*rbegin >= firstChar && *rbegin < endChar) {
|
||||
++(*rbegin);
|
||||
return value;
|
||||
} else if (*rbegin == '\0') {
|
||||
*rbegin = firstChar;
|
||||
return value;
|
||||
} else {
|
||||
*rbegin = firstChar;
|
||||
}
|
||||
}
|
||||
value = toStdArray(std::string(4, '\0') + firstChar);
|
||||
return value;
|
||||
}
|
||||
|
||||
inline bool DemonstrationWidget::checkBeforeInsertion(bool tableTypeIsChain) {
|
||||
size_t quantityOfInserts = m_sbQuantity->value();
|
||||
if (tableTypeIsChain &&
|
||||
(m_pTable->numberOfBuckets() + quantityOfInserts) / m_pTable->size() >
|
||||
10) {
|
||||
outputMessage(
|
||||
"Prohibit insertion when allocating more than 10 elements per chain",
|
||||
"red");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedMakeItems() {
|
||||
using namespace BusinessLogic::Convert;
|
||||
|
||||
bool tableTypeIsChain = getCurrentTableType() == TableType::Chain;
|
||||
if (not checkBeforeInsertion(tableTypeIsChain)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Preparing
|
||||
*/
|
||||
|
||||
if (tableTypeIsChain && m_pStandardModel->columnCount() == 0) {
|
||||
m_pStandardModel->insertColumns(0, m_sbQuantity->value() /
|
||||
m_sbBucketQuantity->value());
|
||||
}
|
||||
|
||||
m_frmProgressBar->setVisible(true);
|
||||
m_progressBar->setValue(0);
|
||||
|
||||
/*
|
||||
* For other thread
|
||||
*/
|
||||
|
||||
setEnabledInsertingProcess(false);
|
||||
m_frmProgressBar->setVisible(true);
|
||||
|
||||
auto differenceNumberOfSuccesses = m_tableInformation.m_numberOfSuccesses;
|
||||
auto differenceNumberOfFailures = m_tableInformation.m_numberOfFailures;
|
||||
|
||||
int value;
|
||||
value_type currentString = toStdArray(m_leFrom->text().toStdString());
|
||||
for (size_t progress = 0, target = m_sbQuantity->value(); progress < target;
|
||||
++progress) {
|
||||
m_pTable->insert(currentString);
|
||||
next(currentString);
|
||||
if (m_stop) {
|
||||
m_stop = false;
|
||||
break;
|
||||
}
|
||||
|
||||
value = static_cast<int>(
|
||||
progress * static_cast<double>(m_progressBar->maximum()) / target);
|
||||
if (value > m_progressBar->value()) {
|
||||
m_progressBar->setValue(value);
|
||||
}
|
||||
|
||||
QApplication::processEvents();
|
||||
}
|
||||
|
||||
updateCharts();
|
||||
updateTableView();
|
||||
|
||||
m_frmProgressBar->setVisible(false);
|
||||
setEnabledInsertingProcess(true);
|
||||
|
||||
/*
|
||||
* Output message
|
||||
*/
|
||||
|
||||
differenceNumberOfSuccesses =
|
||||
m_tableInformation.m_numberOfSuccesses - differenceNumberOfSuccesses;
|
||||
differenceNumberOfFailures =
|
||||
m_tableInformation.m_numberOfFailures - differenceNumberOfFailures;
|
||||
|
||||
m_lblOutputMessages->setText(
|
||||
getColorTextHTML(
|
||||
QString("Successful inserts: %1").arg(differenceNumberOfSuccesses),
|
||||
"green") +
|
||||
"<br>" +
|
||||
getColorTextHTML(QString("Failed inserts : %1")
|
||||
.arg(differenceNumberOfFailures),
|
||||
"red"));
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedInsert() {
|
||||
bool tableTypeIsChain = getCurrentTableType() == TableType::Chain;
|
||||
if (not checkBeforeInsertion(tableTypeIsChain)) {
|
||||
return;
|
||||
}
|
||||
|
||||
m_pTable->insert(toStdArray(m_leInsert->text().toStdString()));
|
||||
outputMessage(m_tableInformation.m_lastInsertion ? "Inserting is successful"
|
||||
: "The insertion has failed",
|
||||
m_tableInformation.m_lastInsertion ? "green" : "red");
|
||||
}
|
||||
|
||||
/*
|
||||
* Other logic
|
||||
*/
|
||||
|
||||
inline auto DemonstrationWidget::getCurrentFactory() const {
|
||||
using namespace BusinessLogic::Hash;
|
||||
|
||||
std::unique_ptr<const Factory::Abstract> factory;
|
||||
bool functionTypeIsFamily =
|
||||
getCurrentFunctionType() == RelationshipType::Family;
|
||||
if (getCurrentAlgorythmType() == RelationshipType::One) {
|
||||
factory = std::make_unique<Factory::One>(
|
||||
functionTypeIsFamily
|
||||
? m_complicatedFunction // The complicated function must be prepared
|
||||
: std::dynamic_pointer_cast<Function::One::Creator>(m_pFunction),
|
||||
std::dynamic_pointer_cast<Algorithm::One::Creator>(m_pAlgorithm));
|
||||
} else if (functionTypeIsFamily) {
|
||||
factory = std::make_unique<Factory::Family>(
|
||||
std::dynamic_pointer_cast<Function::Family::Creator>(m_pFunction),
|
||||
std::dynamic_pointer_cast<Algorithm::Family::Creator>(m_pAlgorithm));
|
||||
} else {
|
||||
std::invalid_argument("function type not defined");
|
||||
}
|
||||
return factory;
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::updateFunctionCreator() {
|
||||
using namespace BusinessLogic::Hash::Function;
|
||||
if (m_rbEquivalent->isChecked()) {
|
||||
m_pFunction = std::make_shared<Equivalent::Creator>();
|
||||
} else if (m_rbStandart->isChecked()) {
|
||||
m_pFunction = std::make_shared<Standart::Creator>();
|
||||
} else { // m_rbFNV1a32bit->isChecked()
|
||||
m_pFunction = std::make_shared<FNV1a::Creator>();
|
||||
}
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::updateAlgorithmCreator() {
|
||||
using namespace BusinessLogic::Hash::Algorithm;
|
||||
if (m_rbLinearProbing->isChecked()) {
|
||||
m_pAlgorithm = std::make_shared<LinearProbing::Creator>();
|
||||
} else if (m_rbQuadraticProbing->isChecked()) {
|
||||
m_pAlgorithm = std::make_shared<QuadraticProbing::Creator>();
|
||||
} else if (m_rbPseudorandomProbing->isChecked()) {
|
||||
m_pAlgorithm = std::make_shared<PseudorandomProbing::Creator>(
|
||||
m_sbFirstInputData->value());
|
||||
} else { // m_rbDoubleHashing->isChecked()
|
||||
m_pAlgorithm = std::make_shared<DoubleHashing::Creator>(
|
||||
m_sbFirstInputData->value(), m_sbSecondInputData->value());
|
||||
}
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::deleteModel() {
|
||||
auto stringListModel = m_tableView->selectionModel();
|
||||
m_tableView->setModel(nullptr);
|
||||
if (stringListModel not_eq nullptr) {
|
||||
delete stringListModel;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Table GUI
|
||||
*/
|
||||
|
||||
inline void DemonstrationWidget::slotUpdateAdditionalInputData() {
|
||||
bool predicate = {getCurrentFunctionType() == RelationshipType::Family};
|
||||
m_gbInputData->setVisible(predicate);
|
||||
m_frmFirstInputData->setVisible(predicate);
|
||||
|
||||
if (getCurrentTableType() == TableType::Chain) {
|
||||
m_rbStandart->setEnabled(true);
|
||||
m_rbEquivalent->setEnabled(true);
|
||||
m_frmSecondInputData->setVisible(false);
|
||||
} else {
|
||||
bool algorythmIsFamily =
|
||||
getCurrentAlgorythmType() == RelationshipType::Family;
|
||||
m_rbEquivalent->setDisabled(algorythmIsFamily);
|
||||
m_rbStandart->setDisabled(algorythmIsFamily);
|
||||
m_frmSecondInputData->setVisible(algorythmIsFamily);
|
||||
|
||||
if (algorythmIsFamily) {
|
||||
m_rbFNV1a32bit->setChecked(true);
|
||||
repaint();
|
||||
m_frmSecondInputData->setVisible(m_rbDoubleHashing->isChecked());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedApply() {
|
||||
using namespace BusinessLogic::Hash;
|
||||
using namespace BusinessLogic::Hash::Function::Pattern;
|
||||
|
||||
if (m_rbDoubleHashing->isChecked() &&
|
||||
m_sbFirstInputData->value() == m_sbSecondInputData->value()) {
|
||||
outputMessage("Hash function coefficients should not match", "red");
|
||||
return;
|
||||
}
|
||||
|
||||
updateFunctionCreator();
|
||||
updateAlgorithmCreator();
|
||||
|
||||
bool tableTypeIsChain = getCurrentTableType() == TableType::Chain;
|
||||
bool functionTypeIsFamily =
|
||||
getCurrentFunctionType() == RelationshipType::Family;
|
||||
|
||||
if (functionTypeIsFamily && (tableTypeIsChain || getCurrentAlgorythmType() ==
|
||||
RelationshipType::One)) {
|
||||
m_complicatedFunction = std::make_shared<FamilyToOne::Creator>(
|
||||
std::dynamic_pointer_cast<Function::Family::Creator>(m_pFunction),
|
||||
m_sbFirstInputData->value());
|
||||
}
|
||||
|
||||
size_t bucketQuantity = m_sbBucketQuantity->value();
|
||||
try {
|
||||
if (tableTypeIsChain) {
|
||||
m_pTable = std::make_unique<Table::Chains>(
|
||||
bucketQuantity,
|
||||
functionTypeIsFamily
|
||||
? *m_complicatedFunction
|
||||
: *std::dynamic_pointer_cast<Function::One::Creator>(m_pFunction),
|
||||
m_alphabetPower);
|
||||
} else {
|
||||
auto factory = getCurrentFactory();
|
||||
m_pTable = std::make_unique<Table::OpenAddressing>(
|
||||
bucketQuantity, *factory, m_alphabetPower);
|
||||
}
|
||||
} catch (const std::bad_alloc &err) {
|
||||
outputMessage("Not enough RAM", "red");
|
||||
return;
|
||||
}
|
||||
|
||||
setEnabledCreateHashTable(false);
|
||||
m_pbFocus->setEnabled(true);
|
||||
m_pTable->signTheObject(this);
|
||||
|
||||
/*
|
||||
* A descendant will notify an ancestor of his own destruction when using
|
||||
* delete
|
||||
*/
|
||||
deleteModel();
|
||||
m_pStandardModel =
|
||||
new QStandardItemModel(bucketQuantity, (tableTypeIsChain ? 0 : 1), this);
|
||||
m_tableView->setModel(m_pStandardModel);
|
||||
|
||||
m_lblOutputMessages->setText(
|
||||
getColorTextHTML("The model was created", "green"));
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedStatistics() {
|
||||
m_tableInformation.m_lastCoefficient =
|
||||
m_pTable->simpleUniformHashingCoefficient();
|
||||
QMessageBox::information(
|
||||
nullptr, "Statistics",
|
||||
QString("Maximum number of collisions:\t%1\n")
|
||||
.arg(m_tableInformation.m_maxCollision) +
|
||||
QString("Number of successful inserts:\t\t%1\n")
|
||||
.arg(m_tableInformation.m_numberOfSuccesses) +
|
||||
QString("Number of failed inserts:\t\t%1\n")
|
||||
.arg(m_tableInformation.m_numberOfFailures) +
|
||||
QString("Simple uniform hashing coefficient:\t%1\n")
|
||||
.arg(m_tableInformation.m_lastCoefficient));
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedFindFree() {
|
||||
QString result;
|
||||
if (m_pTable->numberOfBuckets() == 0) {
|
||||
result = firstChar;
|
||||
} else {
|
||||
value_type currentString = m_tableInformation.m_lastValue;
|
||||
while (m_pTable->isExist(next(currentString)))
|
||||
continue;
|
||||
result = toQString(currentString);
|
||||
}
|
||||
|
||||
m_leFrom->setText(result);
|
||||
m_leInsert->setText(result);
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedStop() {
|
||||
m_stop = true;
|
||||
setEnabledInsertingProcess(true);
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::slotClickedFocus() { updateCharts(); }
|
||||
|
||||
/*
|
||||
* Base GUI
|
||||
*/
|
||||
|
||||
inline void DemonstrationWidget::slotClickedReset() {
|
||||
setEnabledCreateHashTable(true);
|
||||
m_pbFocus->setDisabled(true);
|
||||
|
||||
m_complicatedFunction.reset();
|
||||
m_pTable.release();
|
||||
m_tableInformation.clear();
|
||||
resetAxes();
|
||||
deleteModel();
|
||||
|
||||
outputMessage("The model has been deleted", "green");
|
||||
}
|
||||
|
||||
inline QString
|
||||
DemonstrationWidget::getColorTextHTML(const QString &text,
|
||||
const char *const color) const {
|
||||
return QString(m_fontBeginColorHTML).arg(color) + text + m_fontEndHTML;
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::outputMessage(const QString &text,
|
||||
const char *const color) {
|
||||
m_lblOutputMessages->setText(getColorTextHTML(text, color));
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::setEnabledCreateHashTable(bool flag) {
|
||||
for (QWidget *widget : std::initializer_list<QWidget *>{
|
||||
m_pbApply, m_sbBucketQuantity, m_gbResolutionOfCollisions,
|
||||
m_gbFunction, m_gbInputData}) {
|
||||
widget->setEnabled(flag);
|
||||
}
|
||||
|
||||
if (getCurrentTableType() not_eq TableType::Chain) {
|
||||
m_gbAlgorithm->setEnabled(flag);
|
||||
}
|
||||
m_gbLoadTable->setDisabled(flag);
|
||||
m_pbStatistics->setDisabled(flag);
|
||||
}
|
||||
|
||||
inline void DemonstrationWidget::setEnabledInsertingProcess(bool flag) {
|
||||
for (QWidget *widget : std::initializer_list<QWidget *>{
|
||||
m_leFrom, m_sbQuantity, m_pbMakeItems, m_leInsert, m_pbInsert,
|
||||
m_pbReset, m_pbStatistics, m_pbFindFree}) {
|
||||
widget->setEnabled(flag);
|
||||
}
|
||||
m_pbStop->setDisabled(flag);
|
||||
}
|
||||
@@ -0,0 +1,233 @@
|
||||
#ifndef DEMONSTRATION_WIDGET_H
|
||||
#define DEMONSTRATION_WIDGET_H
|
||||
|
||||
#include "../../Validator/validator.h"
|
||||
#include "SourceCode/BusinessLogic/businessLogic.h"
|
||||
#include "SourceCode/BusinessLogic/hashHeaderFiles.h"
|
||||
#include "hashTable.h"
|
||||
#include "ui_demonstrationWidget.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <thread>
|
||||
|
||||
#include <QChartView>
|
||||
#include <QLineSeries>
|
||||
#include <QStringListModel>
|
||||
#include <QtCharts>
|
||||
|
||||
class DemonstrationWidget
|
||||
: public QWidget,
|
||||
protected Ui::DemonstrationWidget,
|
||||
public BusinessLogic::Hash::Table::Pattern::InterfaceSubscriber {
|
||||
public:
|
||||
using value_type = BusinessLogic::Hash::Table::Abstract::value_type;
|
||||
using table_type = BusinessLogic::Hash::Table::Abstract;
|
||||
|
||||
private:
|
||||
struct TableInformation {
|
||||
public:
|
||||
/* Qt containers */
|
||||
QLineSeries *m_pSeriesNumberOfCollisions;
|
||||
|
||||
/* If successful */
|
||||
std::pair<size_t, size_t> m_lastCoord;
|
||||
size_t m_numberOfSuccesses;
|
||||
size_t m_lastCollision;
|
||||
size_t m_maxCollision;
|
||||
double m_lastCoefficient;
|
||||
double m_maxCoefficient;
|
||||
|
||||
/* If unsuccessful */
|
||||
size_t m_numberOfFailures;
|
||||
|
||||
/* In any case */
|
||||
value_type m_lastValue;
|
||||
bool m_lastInsertion;
|
||||
|
||||
public:
|
||||
TableInformation(const TableInformation &) = delete;
|
||||
TableInformation(TableInformation &&) = delete;
|
||||
|
||||
TableInformation(QLineSeries *maxCollision)
|
||||
: m_pSeriesNumberOfCollisions(maxCollision) {
|
||||
clear();
|
||||
};
|
||||
|
||||
public:
|
||||
void clear();
|
||||
};
|
||||
|
||||
private: // Event filter
|
||||
virtual bool eventFilter(QObject *target, QEvent *event) override {
|
||||
if (target == m_pChartCollisionsView) {
|
||||
QChartView *view = dynamic_cast<QChartView *>(target);
|
||||
QChart *chart = view->chart();
|
||||
|
||||
switch (event->type()) {
|
||||
case QEvent::Wheel: {
|
||||
QWheelEvent *currentEvent = dynamic_cast<QWheelEvent *>(event);
|
||||
|
||||
qreal factor = currentEvent->angleDelta().y() > 0 ? 0.9 : 1.1;
|
||||
QRectF rect = QRectF(chart->plotArea().left(), chart->plotArea().top(),
|
||||
chart->plotArea().width() * factor,
|
||||
chart->plotArea().height() * factor);
|
||||
|
||||
QPointF mousePos = view->mapFromGlobal(QCursor::pos());
|
||||
rect.moveCenter(mousePos);
|
||||
chart->zoomIn(rect);
|
||||
|
||||
QPointF delta = chart->plotArea().center() - mousePos;
|
||||
chart->scroll(delta.x(), -delta.y());
|
||||
|
||||
return true;
|
||||
} break;
|
||||
default: {
|
||||
return false;
|
||||
} break;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
enum class TableType : short { Chain, OpenAdressing, Indefined };
|
||||
enum class RelationshipType : short { One, Family, Indefined };
|
||||
|
||||
private:
|
||||
/*
|
||||
* Constants
|
||||
*/
|
||||
static constexpr char firstChar = '!';
|
||||
static constexpr char endChar = '~';
|
||||
|
||||
QChartView *m_pChartCollisionsView;
|
||||
QStandardItemModel *m_pStandardModel;
|
||||
bool m_stop;
|
||||
|
||||
/*
|
||||
* Business logic
|
||||
*/
|
||||
std::shared_ptr<BusinessLogic::Hash::Function::Abstract::Creator> m_pFunction;
|
||||
std::shared_ptr<BusinessLogic::Hash::Function::One::Creator>
|
||||
m_complicatedFunction;
|
||||
std::shared_ptr<BusinessLogic::Hash::Algorithm::Abstract::Creator>
|
||||
m_pAlgorithm;
|
||||
size_t m_alphabetPower;
|
||||
std::unique_ptr<BusinessLogic::Hash::Table::Abstract> m_pTable;
|
||||
TableInformation m_tableInformation;
|
||||
|
||||
/*
|
||||
* HTML tags
|
||||
*/
|
||||
static constexpr auto m_fontBeginColorHTML = R"(<font color="%1">)";
|
||||
static constexpr auto m_fontEndHTML = R"(</font>)";
|
||||
|
||||
public:
|
||||
DemonstrationWidget(QWidget *pWidget = nullptr);
|
||||
|
||||
public: // Custom slots
|
||||
virtual void successfulInsertion(const table_type *, const value_type &,
|
||||
std::pair<size_t, size_t>, size_t) override;
|
||||
virtual void unsuccessfulInsertion(const table_type *,
|
||||
const value_type &) override;
|
||||
|
||||
private:
|
||||
/*
|
||||
* Business logic
|
||||
*/
|
||||
TableType getCurrentTableType() const {
|
||||
TableType result;
|
||||
result = {m_rbChains->isChecked() ? TableType::Chain
|
||||
: m_rbOpenAdressing->isChecked() ? TableType::OpenAdressing
|
||||
: TableType::Indefined};
|
||||
if (result == TableType::Indefined) {
|
||||
throw std::invalid_argument("table not defined");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
RelationshipType getCurrentFunctionType() const {
|
||||
RelationshipType result;
|
||||
result = {m_rbEquivalent->isChecked() ? RelationshipType::One
|
||||
: m_rbStandart->isChecked() ? RelationshipType::One
|
||||
: m_rbFNV1a32bit->isChecked() ? RelationshipType::Family
|
||||
: RelationshipType::Indefined};
|
||||
if (result == RelationshipType::Indefined) {
|
||||
throw std::invalid_argument("function not defined");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
RelationshipType getCurrentAlgorythmType() const {
|
||||
RelationshipType result;
|
||||
result = {m_rbLinearProbing->isChecked() ? RelationshipType::One
|
||||
: m_rbQuadraticProbing->isChecked() ? RelationshipType::One
|
||||
: m_rbPseudorandomProbing->isChecked() ? RelationshipType::Family
|
||||
: m_rbDoubleHashing->isChecked() ? RelationshipType::Family
|
||||
: RelationshipType::Indefined};
|
||||
if (result == RelationshipType::Indefined) {
|
||||
throw std::invalid_argument("algorythm not defined");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
auto getCurrentFactory() const;
|
||||
void updateFunctionCreator();
|
||||
void updateAlgorithmCreator();
|
||||
void deleteModel();
|
||||
void resetAxes() {
|
||||
m_pChartCollisionsView->chart()
|
||||
->axes(Qt::Horizontal)
|
||||
.front()
|
||||
->setRange(1, 2);
|
||||
m_pChartCollisionsView->chart()->axes(Qt::Vertical).front()->setRange(0, 1);
|
||||
}
|
||||
QString toQString(const value_type &value) {
|
||||
auto convert = value;
|
||||
unsigned size =
|
||||
std::remove(convert.begin(), convert.end(), '\0') - convert.begin();
|
||||
return QString::fromLatin1(convert.data(), size);
|
||||
}
|
||||
value_type toStdArray(std::string &&value) const {
|
||||
value_type result = {'\0', '\0', '\0', '\0', firstChar};
|
||||
std::copy(value.rbegin(), value.rend(), result.rbegin());
|
||||
return result;
|
||||
}
|
||||
value_type &next(value_type &value) const;
|
||||
bool checkBeforeInsertion(bool);
|
||||
|
||||
/*
|
||||
* GUI and displaying
|
||||
*/
|
||||
QString getColorTextHTML(const QString &text, const char *const color) const;
|
||||
void outputMessage(const QString &text, const char *const color);
|
||||
void updateColumns(size_t rowIndex);
|
||||
void updateCharts();
|
||||
void updateTableView();
|
||||
void setEnabledCreateHashTable(bool flag);
|
||||
void setEnabledInsertingProcess(bool flag);
|
||||
|
||||
public slots:
|
||||
void slotTabSwitched(int index) {
|
||||
if (index == 1) {
|
||||
QSplitter *splitter = findChild<QSplitter *>("");
|
||||
auto children = splitter->children();
|
||||
QList<int> sizes{dynamic_cast<QWidget *>(children[0])->minimumHeight(),
|
||||
dynamic_cast<QWidget *>(children[1])->minimumHeight()};
|
||||
splitter->setSizes(sizes);
|
||||
}
|
||||
}
|
||||
|
||||
private slots:
|
||||
void slotUpdateAdditionalInputData();
|
||||
void slotClickedReset();
|
||||
void slotClickedApply();
|
||||
void slotClickedMakeItems();
|
||||
void slotClickedInsert();
|
||||
void slotClickedStatistics();
|
||||
void slotClickedFindFree();
|
||||
void slotClickedStop();
|
||||
void slotClickedFocus();
|
||||
};
|
||||
|
||||
#endif // DEMONSTRATION_WIDGET_H
|
||||
Reference in New Issue
Block a user