GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r709:8d80a1dd4059

Generates unique name for variable duplicate

Alexandre Leroux -

r709:8d80a1dd4059

parent child

Context file:

r709:8d80a1dd4059

Collapse all files

core/include/Common/StringUtils.h created 644 +35 0

@@ -0,0 +1,35
	1	#ifndef SCIQLOP_STRINGUTILS_H
	2	#define SCIQLOP_STRINGUTILS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <vector>
	7
	8	class QString;
	9
	10	/**
	11	* Utility class with methods for strings
	12	*/
	13	struct SCIQLOP_CORE_EXPORT StringUtils {
	14	/**
	15	* Generates a unique name from a default name and a set of forbidden names.
	16	*
	17	* Generating the unique name is done by adding an index to the default name and stopping at the
	18	* first index for which the generated name is not in the forbidden names.
	19	*
	20	* Examples (defaultName, forbiddenNames -> result):
	21	* - "FGM", {"FGM"} -> "FGM1"
	22	* - "FGM", {"ABC"} -> "FGM"
	23	* - "FGM", {"FGM", "FGM1"} -> "FGM2"
	24	* - "FGM", {"FGM", "FGM2"} -> "FGM1"
	25	* - "", {"ABC"} -> "1"
	26	*
	27	* @param defaultName the default name
	28	* @param forbiddenNames the set of forbidden names
	29	* @return the unique name generated
	30	*/
	31	static QString uniqueName(const QString &defaultName,
	32	const std::vector<QString> &forbiddenNames) noexcept;
	33	};
	34
	35	#endif // SCIQLOP_STRINGUTILS_H

core/src/Common/StringUtils.cpp created 644 +30 0

@@ -0,0 +1,30
	1	#include "Common/StringUtils.h"
	2
	3	#include <QRegExp>
	4	#include <QString>
	5
	6	#include <set>
	7
	8	QString StringUtils::uniqueName(const QString &defaultName,
	9	const std::vector<QString> &forbiddenNames) noexcept
	10	{
	11	// Gets the base of the unique name to generate, by removing trailing number (for example, base
	12	// name of "FGM12" is "FGM")
	13	auto baseName = defaultName;
	14	baseName.remove(QRegExp{QStringLiteral("\\d*$")});
	15
	16	// Finds the unique name by adding an index to the base name and stops when the generated name
	17	// isn't forbidden
	18	QString newName{};
	19	auto forbidden = true;
	20	for (auto i = 0; forbidden; ++i) {
	21	newName = (i == 0) ? baseName : baseName + QString::number(i);
	22	forbidden = newName.isEmpty()
	23	\|\| std::any_of(forbiddenNames.cbegin(), forbiddenNames.cend(),
	24	[&newName](const auto &name) {
	25	return name.compare(newName, Qt::CaseInsensitive) == 0;
	26	});
	27	}
	28
	29	return newName;
	30	}

core/tests/Common/TestStringUtils.cpp created 644 +50 0

@@ -0,0 +1,50
	1	#include <Common/StringUtils.h>
	2
	3	#include <QObject>
	4	#include <QtTest>
	5
	6	class TestStringUtils : public QObject {
	7	Q_OBJECT
	8
	9	private slots:
	10	void testUniqueName_data();
	11	void testUniqueName();
	12	};
	13
	14	void TestStringUtils::testUniqueName_data()
	15	{
	16	// ////////////// //
	17	// Test structure //
	18	// ////////////// //
	19
	20	QTest::addColumn<QString>("defaultName");
	21	QTest::addColumn<std::vector<QString> >("forbiddenNames");
	22	QTest::addColumn<QString>("expectedName");
	23
	24	// ////////// //
	25	// Test cases //
	26	// ////////// //
	27
	28	QTest::newRow("uniqueName") << "FGM" << std::vector<QString>{"FGM2"} << "FGM";
	29	QTest::newRow("uniqueName2") << "FGM2" << std::vector<QString>{"FGM", "FGM1", "FGM2"} << "FGM3";
	30	QTest::newRow("uniqueName3") << "FGM1" << std::vector<QString>{"FGM1"} << "FGM";
	31	QTest::newRow("uniqueName4") << "FGM" << std::vector<QString>{"FGM"} << "FGM1";
	32	QTest::newRow("uniqueName5") << "FGM" << std::vector<QString>{"FGM", "FGM1", "FGM3"} << "FGM2";
	33	QTest::newRow("uniqueName6") << "FGM" << std::vector<QString>{"A", "B", "C"} << "FGM";
	34	QTest::newRow("uniqueName7") << "FGM" << std::vector<QString>{"fGm", "FGm1", "Fgm2"} << "FGM3";
	35	QTest::newRow("uniqueName8") << "" << std::vector<QString>{"A", "B", "C"} << "1";
	36	QTest::newRow("uniqueName9") << "24" << std::vector<QString>{"A", "B", "C"} << "1";
	37	}
	38
	39	void TestStringUtils::testUniqueName()
	40	{
	41	QFETCH(QString, defaultName);
	42	QFETCH(std::vector<QString>, forbiddenNames);
	43	QFETCH(QString, expectedName);
	44
	45	auto result = StringUtils::uniqueName(defaultName, forbiddenNames);
	46	QCOMPARE(result, expectedName);
	47	}
	48
	49	QTEST_MAIN(TestStringUtils)
	50	#include "TestStringUtils.moc"

core/meson.build +1 0

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableCacheStrategy.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
+              'src/Common/StringUtils.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableCacheStrategy.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/Variable/VariableModel.cpp +15 0

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
+            #include <Common/StringUtils.h>
             #include <Data/IDataSeries.h>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto UNIT_COLUMN = 3;
             const auto MISSION_COLUMN = 4;
             const auto PLUGIN_COLUMN = 5;
             const auto NB_COLUMNS = 6;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},       {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}},  {UNIT_COLUMN, {QObject::tr("Unit")}},
                 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
+            QString uniqueName(const QString &defaultName,
+                               const std::vector<std::shared_ptr<Variable> > &variables)
+            {
+                auto forbiddenNames = std::vector<QString>(variables.size());
+                std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
+                               [](const auto &variable) { return variable->name(); });
+                auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
+                Q_ASSERT(!uniqueName.isEmpty());
+                return uniqueName;
+            }
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             void VariableModel::addVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
+                // Generates unique name for the variable
+                variable->setName(uniqueName(variable->name(), impl->m_Variables));
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 addVariable(variable);
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             std::vector<std::shared_ptr<Variable> > VariableModel::variables() const
             {
                 return impl->m_Variables;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case TEND_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

core/tests/meson.build +1 0

             tests = [
+              [['Common/TestStringUtils.cpp'],'test_string_utils','StringUtils test'],
               [['Data/TestDataSeries.cpp'],'test_data','DataSeries test'],
               [['Data/TestOneDimArrayData.cpp'],'test_1d','One Dim Array test'],
               [['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
               [['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
               [['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
               [['Variable/TestVariable.cpp'],'test_variable','Variable test']
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       dependencies : [sciqlop_core, qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])])
             endforeach

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages