HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r14:df856114eba1

Followed Clazy and Clang advises and disabled few old tests...

jeandet -

r14:df856114eba1

parent child

Context file:

r14:df856114eba1

include/Data/DateTimeRange.h +3 -3

                     std::vector<DateTimeRange> result;
                     if(std::isnan(other.m_TStart)||std::isnan(other.m_TEnd)||!this->intersect(other))
                     {
-                        result.push_back({m_TStart, m_TEnd});
+                        result.emplace_back(m_TStart, m_TEnd);
                     }
                     else
                     {
                         if(this->m_TStart<other.m_TStart)
                         {
-                            result.push_back({this->m_TStart, other.m_TStart});
+                            result.emplace_back(this->m_TStart, other.m_TStart);
                         }
                         if(this->m_TEnd>other.m_TEnd)
                         {
-                            result.push_back({this->m_TEnd, other.m_TEnd});
+                            result.emplace_back(this->m_TEnd, other.m_TEnd);
                         }
                     }
                     return result;

include/Data/DateTimeRangeHelper.h +5 -5

             namespace DateTimeRangeHelper {
-                bool isnan(const DateTimeRange& range)
+                inline bool isnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) && std::isnan(range.m_TEnd);
                 }
-                bool hasnan(const DateTimeRange& range)
+                inline bool hasnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) || std::isnan(range.m_TEnd);
                 }
-                bool isPureShift(const DateTimeRange& range1, const DateTimeRange& range2)
+                inline bool isPureShift(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     return SciQLop::numeric::almost_equal<double>(range1.delta(), range2.delta(), 1)
                             && !SciQLop::numeric::almost_equal(range1.m_TStart, range2.m_TStart, 1);
                 }
-                bool isPureZoom(const DateTimeRange& range1, const DateTimeRange& range2)
+                inline bool isPureZoom(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     return !SciQLop::numeric::almost_equal<double>(range1.delta(),range2.delta(),1)&&
                             SciQLop::numeric::almost_equal<double>(range1.center(), range2.center(),1);
                  * @return trnaformation applied to range1 to get range2 or an object of type
                  * InvalidDateTimeRangeTransformation if the transformation has NaN or forbiden values
                  */
-                std::variant<DateTimeRangeTransformation, InvalidDateTimeRangeTransformation>
+                inline std::variant<DateTimeRangeTransformation, InvalidDateTimeRangeTransformation>
                 computeTransformation(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     double zoom = range2.delta()/range1.delta();

include/Variable/VariableController2.h +8 -7

             public:
                 explicit VariableController2();
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
-                                                         std::shared_ptr<IDataProvider> provider, const DateTimeRange &range);
+                                                         const std::shared_ptr<IDataProvider>& provider,
+                                                         const DateTimeRange &range);
-                void deleteVariable(std::shared_ptr<Variable> variable);
+                void deleteVariable(const std::shared_ptr<Variable>& variable);
-                void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+                void changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
-                void asyncChangeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+                void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
                 const std::set<std::shared_ptr<Variable>> variables();
-                void synchronize(std::shared_ptr<Variable> var, std::shared_ptr<Variable> with);
+                void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
             signals:
-                void variableAdded(std::shared_ptr<Variable>);
+                void variableAdded(const std::shared_ptr<Variable>&);
-                void variableDeleted(std::shared_ptr<Variable>);
+                void variableDeleted(const std::shared_ptr<Variable>&);
             };

src/Variable/VariableController2.cpp +13 -13

                 QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                 QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                 std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
-                bool p_contains(std::shared_ptr<Variable> variable)
+                bool p_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return _providers.contains(variable->ID());
                 }
-                bool v_contains(std::shared_ptr<Variable> variable)
+                bool v_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return SciQLop::containers::contains(this->_variables, variable);
                 }
-                bool sg_contains(std::shared_ptr<Variable> variable)
+                bool sg_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return _synchronizationGroups.contains(variable->ID());
                 }
-                void _changeRange(std::shared_ptr<Variable> var, DateTimeRange r)
+                void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     auto provider = _providers[var->ID()];
                     DateTimeRange newCacheRange;
                 {
                     auto newVar = std::make_shared<Variable>(name,metadata);
                     this->_variables[newVar->ID()] = newVar;
-                    this->_providers[newVar->ID()] = provider;
+                    this->_providers[newVar->ID()] = std::move(provider);
                     this->_synchronizationGroups[newVar->ID()] = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                     return newVar;
                 }
-                void deleteVariable(std::shared_ptr<Variable> variable)
+                void deleteVariable(const std::shared_ptr<Variable>& variable)
                 {
                     /*
                      * Removing twice a var is ok but a var without provider has to be a hard error
                         SCIQLOP_ERROR(VariableController2Private, "No provider found for given variable");
                 }
-                void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
+                void changeRange(const std::shared_ptr<Variable>& variable, DateTimeRange r)
                 {
                     if(p_contains(variable))
                     {
                     }
                 }
-                void synchronize(std::shared_ptr<Variable> var, std::shared_ptr<Variable> with)
+                void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with)
                 {
                     if(v_contains(var) && v_contains(with))
                     {
                 const std::set<std::shared_ptr<Variable>> variables()
                 {
                     std::set<std::shared_ptr<Variable>> vars;
-                    for(auto var:_variables.values())
+                    for(const auto  &var:_variables)
                     {
                         vars.insert(var);
                     }
                 :impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
-            std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
+            std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, const std::shared_ptr<IDataProvider>& provider, const DateTimeRange &range)
             {
                 auto var =  impl->createVariable(name, metadata, provider);
                 emit variableAdded(var);
                 return var;
             }
-            void VariableController2::deleteVariable(std::shared_ptr<Variable> variable)
+            void VariableController2::deleteVariable(const std::shared_ptr<Variable>& variable)
             {
                 impl->deleteVariable(variable);
                 emit variableDeleted(variable);
             }
-            void VariableController2::changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
+            void VariableController2::changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
             {
                 impl->changeRange(variable, r);
             }
                 return impl->variables();
             }
-            void VariableController2::synchronize(std::shared_ptr<Variable> var, std::shared_ptr<Variable> with)
+            void VariableController2::synchronize(const std::shared_ptr<Variable> &var, const std::shared_ptr<Variable> &with)
             {
                 impl->synchronize(var, with);
             }

tests/Variable/TestVariable.cpp +1 0

                 Q_OBJECT
             private slots:
+                void initTestCase() { QSKIP("Skip it"); }
                 void testClone_data();
                 void testClone();

tests/Variable/TestVariableCacheController.cpp +2 0

                 Q_OBJECT
             private slots:
+                void initTestCase() { QSKIP("Skip it"); }
                 void testProvideNotInCacheDateTimeList();
                 void testAddDateTime();

tests/Variable/TestVariableController.cpp +2 0

                 Q_OBJECT
             private slots:
+                void initTestCase() { QSKIP("Skip it"); }
                 /// Test removes variable from controller
                 void testDeleteVariable();
             };

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