HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r94:29637e951955

Switched to cpp_utils package...

jeandet -

r94:29637e951955

parent child

Context file:

r94:29637e951955

include/Data/DateTimeRange.h +5 -5

             #ifndef SCIQLOP_DATETIMERANGE_H
             #define SCIQLOP_DATETIMERANGE_H
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
-            #include <Common/Numeric.h>
+            #include <Numeric.h>
             #include <QDebug>
             #include <QObject>
             #include <cmath>
             #include <opaque/numeric_typedef.hpp>
             template<typename T>
             struct Seconds
                 : opaque::numeric_typedef<T, Seconds<T>>,
                   opaque::binop::multipliable<Seconds<T>, true, Seconds<T>, T, T>,
                   opaque::binop::dividable<Seconds<T>, true, Seconds<T>, T, T>,
                   opaque::binop::addable<Seconds<T>, true, Seconds<T>, T, T>,
                   opaque::binop::subtractable<Seconds<T>, true, Seconds<T>, T, T>
             {
               using base = opaque::numeric_typedef<T, Seconds<T>>;
               using base::base;
               operator T() const { return this->value; }
             };
             struct InvalidDateTimeRangeTransformation
             {};
             struct DateTimeRangeTransformation
             {
               double zoom;
               Seconds<double> shift;
               bool operator==(const DateTimeRangeTransformation& other) const
               {
-                return SciQLop::numeric::almost_equal(zoom, other.zoom, 1) &&
+                return cpp_utils::numeric::almost_equal(zoom, other.zoom, 1) &&
-                       SciQLop::numeric::almost_equal<double>(shift, other.shift, 1);
+                       cpp_utils::numeric::almost_equal<double>(shift, other.shift, 1);
               }
               DateTimeRangeTransformation
               merge(const DateTimeRangeTransformation& other) const
               {
                 return DateTimeRangeTransformation{zoom * other.zoom, shift + other.shift};
               }
             };
             /**
              * @brief The SqpRange struct holds the information of time parameters
              */
             struct DateTimeRange
             {
               DateTimeRange() : m_TStart(std::nan("")), m_TEnd(std::nan("")) {}
               DateTimeRange(double TStart, double TEnd) : m_TStart(TStart), m_TEnd(TEnd) {}
               DateTimeRange(const std::pair<double, double>& range)
                   : m_TStart(range.first), m_TEnd(range.second)
               {}
               /// Creates SqpRange from dates and times
               static DateTimeRange fromDateTime(const QDate& startDate,
                                                 const QTime& startTime,
                                                 const QDate& endDate, const QTime& endTime)
               {
                 return {
                     DateUtils::secondsSinceEpoch(QDateTime{startDate, startTime, Qt::UTC}),
                     DateUtils::secondsSinceEpoch(QDateTime{endDate, endTime, Qt::UTC})};
               }
               static DateTimeRange fromDateTime(const QDateTime& start,
                                                 const QDateTime& end)
               {
                 return {DateUtils::secondsSinceEpoch(start),
                         DateUtils::secondsSinceEpoch(end)};
               }
               /// Start time (UTC)
               double m_TStart;
               /// End time (UTC)
               double m_TEnd;
               Seconds<double> delta() const noexcept
               {
                 return Seconds<double>{this->m_TEnd - this->m_TStart};
               }
               bool contains(const DateTimeRange& dateTime) const noexcept
               {
                 return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
               }
               Seconds<double> center() const noexcept
               {
                 return Seconds<double>((m_TStart + m_TEnd) / 2.);
               }
               bool intersect(const DateTimeRange& dateTime) const noexcept
               {
                 return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
               }
               inline DateTimeRange transform(const DateTimeRangeTransformation& tr) const
                   noexcept;
               bool operator==(const DateTimeRange& other) const
               {
-                return SciQLop::numeric::almost_equal(m_TStart, other.m_TStart, 1) &&
+                return cpp_utils::numeric::almost_equal(m_TStart, other.m_TStart, 1) &&
-                       SciQLop::numeric::almost_equal(m_TEnd, other.m_TEnd, 1);
+                       cpp_utils::numeric::almost_equal(m_TEnd, other.m_TEnd, 1);
               }
               bool operator!=(const DateTimeRange& other) const
               {
                 return !(*this == other);
               }
               void grow(double factor) noexcept
               {
                 double grow_v{delta() * (factor - 1.) / 2.};
                 m_TStart -= grow_v;
                 m_TEnd += grow_v;
               }
               void shrink(double factor) noexcept
               {
                 double shrink_v{this->delta() * (1. - factor) / 2.};
                 m_TStart += shrink_v;
                 m_TEnd -= shrink_v;
               }
               DateTimeRange& operator*=(double k)
               {
                 this->grow(k);
                 return *this;
               }
               DateTimeRange& operator/=(double k)
               {
                 this->shrink(k);
                 return *this;
               }
               // compute set difference
               std::vector<DateTimeRange> operator-(const DateTimeRange& other) const
               {
                 std::vector<DateTimeRange> result;
                 if(std::isnan(other.m_TStart) || std::isnan(other.m_TEnd) ||
                    !this->intersect(other))
                 { result.emplace_back(m_TStart, m_TEnd); }
                 else
                 {
                   if(this->m_TStart < other.m_TStart)
                   { result.emplace_back(this->m_TStart, other.m_TStart); }
                   if(this->m_TEnd > other.m_TEnd)
                   { result.emplace_back(other.m_TEnd, this->m_TEnd); }
                 }
                 return result;
               }
             };
             template<class T> DateTimeRange& operator+=(DateTimeRange& r, Seconds<T> offset)
             {
               shift(r, offset);
               return r;
             }
             template<class T> DateTimeRange& operator-=(DateTimeRange& r, Seconds<T> offset)
             {
               shift(r, -offset);
               return r;
             }
             template<class T> void shift(DateTimeRange& r, Seconds<T> offset)
             {
               r.m_TEnd += static_cast<double>(offset);
               r.m_TStart += static_cast<double>(offset);
             }
             inline DateTimeRange operator*(const DateTimeRange& r, double k)
             {
               DateTimeRange result{r};
               result.grow(k);
               return result;
             }
             inline DateTimeRange operator/(const DateTimeRange& r, double k)
             {
               DateTimeRange result{r};
               result.shrink(k);
               return result;
             }
             template<class T>
             DateTimeRange operator+(const DateTimeRange& r, Seconds<T> offset)
             {
               DateTimeRange result{r};
               shift(result, offset);
               return result;
             }
             template<class T>
             DateTimeRange operator-(const DateTimeRange& r, Seconds<T> offset)
             {
               DateTimeRange result{r};
               shift(result, -offset);
               return result;
             }
             const auto INVALID_RANGE =
                 DateTimeRange{std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN()};
             inline QDebug operator<<(QDebug d, DateTimeRange obj)
             {
               auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
               auto tendDateTimeEnd   = DateUtils::dateTime(obj.m_TEnd);
               d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
               return d;
             }
             DateTimeRange
             DateTimeRange::transform(const DateTimeRangeTransformation& tr) const noexcept
             {
               return DateTimeRange{*this} * tr.zoom + tr.shift;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, DateTimeRange)
             #endif // SCIQLOP_DATETIMERANGE_H

include/Data/DateTimeRangeHelper.h +6 -6

             #ifndef SCIQLOP_DATETIMERANGEHELPER_H
             #define SCIQLOP_DATETIMERANGEHELPER_H
             #include <optional>
             #include <cmath>
             #include <variant>
             #include <QObject>
             #include <QDebug>
             #include <opaque/numeric_typedef.hpp>
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
-            #include <Common/Numeric.h>
+            #include <Numeric.h>
             #include <Data/DateTimeRange.h>
             enum class TransformationType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
             namespace DateTimeRangeHelper {
                 inline bool isnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) && std::isnan(range.m_TEnd);
                 }
                 inline bool hasnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) || std::isnan(range.m_TEnd);
                 }
                 inline bool isPureShift(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
-                    return SciQLop::numeric::almost_equal<double>(range1.delta(), range2.delta(), 1)
+                    return cpp_utils::numeric::almost_equal<double>(range1.delta(), range2.delta(), 1)
-                            && !SciQLop::numeric::almost_equal(range1.m_TStart, range2.m_TStart, 1);
+                            && !cpp_utils::numeric::almost_equal(range1.m_TStart, range2.m_TStart, 1);
                 }
                 inline bool isPureZoom(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
-                    return !SciQLop::numeric::almost_equal<double>(range1.delta(),range2.delta(),1)&&
+                    return !cpp_utils::numeric::almost_equal<double>(range1.delta(),range2.delta(),1)&&
-                            SciQLop::numeric::almost_equal<double>(range1.center(), range2.center(),1);
+                            cpp_utils::numeric::almost_equal<double>(range1.center(), range2.center(),1);
                 }
                 /**
                  * @brief computeTransformation such as range2 = zoom*range1 + shift
                  * @param range1
                  * @param range2
                  * @return trnaformation applied to range1 to get range2 or an object of type
                  * InvalidDateTimeRangeTransformation if the transformation has NaN or forbiden values
                  */
                 inline std::optional<DateTimeRangeTransformation>
                 computeTransformation(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     std::optional<DateTimeRangeTransformation> transformation;
                     double zoom = range2.delta()/range1.delta();
                     Seconds<double> shift = range2.center() - (range1*zoom).center();
                     bool zoomValid = zoom!=0. && !std::isnan(zoom) && !std::isinf(zoom);
                     bool shiftValid = !std::isnan(shift.value) && !std::isinf(shift.value);
                     if(zoomValid && shiftValid)
                         transformation = DateTimeRangeTransformation{zoom, shift};
                     return transformation;
                 }
                 inline TransformationType getTransformationType(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     auto transformation = computeTransformation (range1,range2);
                     if(transformation.has_value ())
                     {
-                        if(SciQLop::numeric::almost_equal(transformation->zoom,1.))
+                        if(cpp_utils::numeric::almost_equal(transformation->zoom,1.))
                         {
                             if(transformation->shift > 0.)
                                 return TransformationType::PanRight;
                             return TransformationType::PanLeft;
                         }
                         if(transformation->zoom > 0.)
                             return TransformationType::ZoomOut;
                         return TransformationType::ZoomIn;
                     }
                     return TransformationType::Unknown;
                 }
             }
             #endif // SCIQLOP_DATETIMERANGEHELPER_H

include/Data/IDataProvider.h +1 -1

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include "CoreGlobal.h"
             #include <Common/MetaTypes.h>
-            #include <Common/deprecate.h>
+            #include <deprecate.h>
             #include <Data/DateTimeRange.h>
             #include <QObject>
             #include <QUuid>
             #include <TimeSeries.h>
             #include <functional>
             #include <memory>
             class DataProviderParameters;
             class IDataSeries;
             DEPRECATE(class QNetworkReply; class QNetworkRequest;)
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to
              * various parameters (time interval, product to retrieve the data, etc.) Since
              * its client mihgt use it from different threads it has to be either stateless
              * and/or thread safe
              *
              * @sa IDataSeries
              */
             class SCIQLOP_CORE_EXPORT IDataProvider : public QObject
             {
               Q_OBJECT
               QUuid _id=QUuid::createUuid();
             public:
               virtual ~IDataProvider() noexcept = default;
               // virtual std::shared_ptr<IDataProvider> clone() const = 0;
               // Synchronous call -> asyncGetData may be written for asynchronous get
               virtual TimeSeries::ITimeSerie*
               getData(const DataProviderParameters& parameters) = 0;
               QUuid id() const { return _id; }
               QString name()
               {
                 return QString("%1-%2").arg(this->metaObject()->className()).arg(id().toString());
               }
             signals:
               void progress(QUuid requestID, double progress);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY,
                                        std::shared_ptr<IDataProvider>)
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
                                        std::function<void(QNetworkReply*, QUuid)>)
             #endif // SCIQLOP_IDATAPROVIDER_H

include/DataSource/DataSourceItem.h +1 -1

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
-            #include <Common/trees.h>
+            #include <trees/algorithms.hpp>
             #include <QVariant>
             #include <QVector>
             #include <iostream>
             #include <iomanip>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType
             {
               NODE,
               PRODUCT,
               COMPONENT
             };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a
              * data source. A data source has a tree structure that is made up of a main
              * DataSourceItem object (root) containing other DataSourceItem objects
              * (children). For each DataSourceItem can be associated a set of data
              * representing it.
              */
             class SCIQLOP_CORE_EXPORT DataSourceItem
             {
             public:
               using iterator_type = decltype (std::begin(std::declval<std::vector<std::unique_ptr<DataSourceItem>>>()));
               using const_iterator_type = decltype (std::cbegin(std::declval<std::vector<std::unique_ptr<DataSourceItem>>>()));
               /// Key associated with the name of the item
               static const QString NAME_DATA_KEY;
               /// Key associated with the plugin of the item
               static const QString PLUGIN_DATA_KEY;
               /// Key associated with a unique id of the plugin
               static const QString ID_DATA_KEY;
               explicit DataSourceItem(DataSourceItemType type, const QString& name);
               explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
               std::unique_ptr<DataSourceItem> clone() const;
               /// @return the actions of the item as a vector
               QVector<DataSourceItemAction*> actions() const noexcept;
               /**
                * Adds an action to the item. The item takes ownership of the action, and the
                * action is automatically associated to the item
                * @param action the action to add
                */
               void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
               /**
                * Adds a child to the item. The item takes ownership of the child.
                * @param child the child to add
                */
               void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
               /**
                * Returns the item's child associated to an index
                * @param childIndex the index to search
                * @return a pointer to the child if index is valid, nullptr otherwise
                */
               DataSourceItem* child(int childIndex) const noexcept;
               int childCount() const noexcept;
               /**
                * Get the data associated to a key
                * @param key the key to search
                * @return the data found if key is valid, default QVariant otherwise
                */
               QVariant data(const QString& key) const noexcept;
               /// Gets all data
               QVariantHash data() const noexcept;
               /**
                * Merge in the item the source item passed as parameter.
                *
                * The merge is done by adding as child of the item the complete tree
                * represented by the source item. If a part of the tree already exists in the
                * item (based on the name of the nodes), it is merged by completing the
                * existing tree by items "leaves" (products, components or nodes with no
                * child).
                *
                * For example, with item representing the tree:
                * R (root node)
                *   - N1 (node)
                *     -- N11 (node)
                *        --- P1 (product)
                *        --- P2 (product)
                *   - N2 (node)
                *
                * and the source item representing the tree:
                * N1 (root node)
                *   - N11 (node)
                *     -- P3 (product)
                *   - N12 (node)
                *
                * The leaves of the source item to merge into the item are N1/N11/P3 and
                * N1/N12 => we therefore have the following merge result:
                * R
                *   - N1
                *     -- N11
                *        --- P1
                *        --- P2
                *        --- P3 (added leaf)
                *     -- N12 (added leaf)
                *
                * @param item the source item
                * @remarks No control is performed on products or components that are merged
                * into the same tree part (two products or components may have the same name)
                * @remarks the merge is made by copy (source item is not changed and still
                * exists after the operation)
                */
               void merge(const DataSourceItem& item);
               bool isRoot() const noexcept;
               QString name() const noexcept;
               /**
                * Get the item's parent
                * @return a pointer to the parent if it exists, nullptr if the item is a root
                */
               DataSourceItem* parentItem() const noexcept;
               /**
                * Gets the item's root
                * @return the top parent, the item itself if it's the root item
                */
               const DataSourceItem& rootItem() const noexcept;
               /**
                * Sets or appends a value to a key
                * @param key the key
                * @param value the value
                * @param append if true, the value is added to the values already existing
                * for the key, otherwise it replaces the existing values
                */
               void setData(const QString& key, const QVariant& value,
                            bool append = false) noexcept;
               DataSourceItemType type() const noexcept;
               /**
                * @brief Searches the first child matching the specified data.
                * @param data The data to search.
                * @param recursive So the search recursively.
                * @return the item matching the data or nullptr if it was not found.
                */
               DataSourceItem* findItem(const QVariantHash& data, bool recursive);
               DataSourceItem* findItem(const QString& name);
               /**
                * @brief Searches the first child matching the specified \p ID_DATA_KEY in
                * its metadata.
                * @param id The id to search.
                * @param recursive So the search recursively.
                * @return the item matching the data or nullptr if it was not found.
                */
               DataSourceItem* findItem(const QString& datasourceIdKey, bool recursive);
               bool operator==(const DataSourceItem& other);
               bool operator!=(const DataSourceItem& other);
               iterator_type begin() noexcept;
               iterator_type end() noexcept;
               const_iterator_type begin()const noexcept;
               const_iterator_type end()const  noexcept;
               const_iterator_type cbegin()const noexcept;
               const_iterator_type cend()const  noexcept;
             private:
               class DataSourceItemPrivate;
               spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

include/Variable/Variable2.h +1 -1

             #ifndef SCIQLOP_VARIABLE2_H
             #define SCIQLOP_VARIABLE2_H
             #include "CoreGlobal.h"
             #include <Common/MetaTypes.h>
-            #include <Common/deprecate.h>
+            #include <deprecate.h>
             #include <Common/spimpl.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
             #include <Data/MultiComponentTimeSerie.h>
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <QDataStream>
             #include <QObject>
             #include <QReadWriteLock>
             #include <QUuid>
             #include <TimeSeries.h>
             #include <optional>
             class SCIQLOP_CORE_EXPORT Variable2 : public QObject
             {
               Q_OBJECT
             public:
               explicit Variable2(const QString& name, const QVariantHash& metadata = {});
               /// Copy ctor
               explicit Variable2(const Variable2& other);
               std::shared_ptr<Variable2> clone() const;
               QString name();
               void setName(const QString& name);
               DateTimeRange range();
               void setRange(const DateTimeRange& range);
               std::optional<DateTimeRange> realRange();
               std::size_t nbPoints();
               /// @return the data of the variable, nullptr if there is no data
               std::shared_ptr<TimeSeries::ITimeSerie> data();
               /// @return the type of data that the variable holds
               DataSeriesType type();
               QVariantHash metadata() const noexcept;
               //  void setData(const std::vector<AnyTimeSerie*>& dataSeries,
               //               const DateTimeRange& range, bool notify = true);
               void setData(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
                            const DateTimeRange& range, bool notify = true);
               static QByteArray
               mimeData(const std::vector<std::shared_ptr<Variable2>>& variables)
               {
                 auto encodedData = QByteArray{};
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 for(auto& var : variables)
                 {
                   stream << var->ID().toByteArray();
                 }
                 return encodedData;
               }
               static std::vector<QUuid> IDs(QByteArray mimeData)
               {
                 std::vector<QUuid> variables;
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 std::transform(std::cbegin(ids), std::cend(ids),
                                std::back_inserter(variables),
                                [](const auto& id) { return id.toByteArray(); });
                 return variables;
               }
               operator QUuid() { return _uuid; }
               QUuid ID() { return _uuid; }
             signals:
               void updated(QUuid ID);
             private:
               struct VariablePrivate;
               spimpl::unique_impl_ptr<VariablePrivate> impl;
               QUuid _uuid;
               QReadWriteLock m_lock;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable2>)
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY,
                                        QVector<std::shared_ptr<Variable2>>)
             #endif // SCIQLOP_VARIABLE2_H

include/Variable/VariableSynchronizationGroup2.h +2 -2

             #ifndef SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H
             #define SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H
             #include <QUuid>
             #include <set>
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             /**
              * @brief The VariableSynchronizationGroup2 class holds a list of Variables uuid which are synchronized
              * @note This class is part of SciQLop internals, as a normal user you shouldn't have to care about it
              */
             class SCIQLOP_CORE_EXPORT VariableSynchronizationGroup2
             {
             public:
                 explicit VariableSynchronizationGroup2()=default;
                 /**
                  * @brief VariableSynchronizationGroup2 is a convenience ctor to build a group with a default variable
                  * @param variable
                  */
                 explicit VariableSynchronizationGroup2(QUuid variable)
                     :_variables{{variable}}
                 {}
                 /**
                  * @brief addVariable adds the given variable to the group, does nothing if the varaible is alredy in the group
                  * @param variable
                  * @sa removeVariable
                  */
                 void addVariable(QUuid variable) noexcept
                 {
                     this->_variables.insert(variable);
                 }
                 /**
                  * @brief removeVariable removes the given variable from the group, does nothing if the varaible is not in the group
                  * @param variable
                  * @sa addVariable
                  */
                 void removeVariable(QUuid variable) noexcept
                 {
                     this->_variables.erase(variable);
                 }
                 /**
                  * @brief contains checks if the given variable is in the group
                  * @param variable
                  * @return true if the variable is in the group
                  */
                 bool contains(QUuid variable) const noexcept
                 {
-                    return SciQLop::containers::contains(this->_variables,variable);
+                    return cpp_utils::containers::contains(this->_variables,variable);
                 }
                 /**
                  * @brief variables
                  * @return the list of synchronized variables in this group as a std::set
                  */
                 const std::set<QUuid> &variables() const noexcept
                 {
                     return this->_variables;
                 }
                 inline bool isEmpty()
                 {
                     return _variables.size()==0;
                 }
                 inline QUuid ID(){return _ID;}
                 operator QUuid() {return _ID;}
             private:
                 std::set<QUuid> _variables;
                 QUuid _ID = QUuid::createUuid();
             };
             #endif // SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H

include/Variable/private/VCTransaction.h +1 -1

             #pragma once
             #include "Variable/VariableSynchronizationGroup2.h"
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <Data/IDataProvider.h>
             #include <QObject>
             #include <QReadWriteLock>
             #include <QRunnable>
             #include <QThreadPool>
             #include <TimeSeries.h>
             #include <Variable/Variable2.h>
             struct VCTransaction
             {
               VCTransaction(QUuid refVar, DateTimeRange range, int varCount)
                   : refVar{refVar}, range{range}, _remainingVars{varCount}
               {}
               QUuid refVar;
               DateTimeRange range;
               bool ready()
               {
                 QReadLocker lock{&_lock};
                 return _remainingVars == 0;
               }
               bool done()
               {
                 QWriteLocker lock{&_lock};
                 _remainingVars -= 1;
                 return _remainingVars == 0;
               }
             private:
               QReadWriteLock _lock;
               int _remainingVars;
             };
             class TransactionExe : public QObject, public QRunnable
             {
               Q_OBJECT
               std::shared_ptr<Variable2> _variable;
               std::shared_ptr<IDataProvider> _provider;
               std::vector<DateTimeRange> _ranges;
               DateTimeRange _range;
               bool _overwrite;
             public:
               TransactionExe(const std::shared_ptr<Variable2>& variable,
                              const std::shared_ptr<IDataProvider>& provider,
                              const std::vector<DateTimeRange>& ranges, DateTimeRange range,
                              bool overwrite = true)
                   : _variable{variable}, _provider{provider}, _ranges{ranges},
                     _range{range}, _overwrite{overwrite}
               {
                 setAutoDelete(true);
               }
               void run() override
               {
                 std::vector<TimeSeries::ITimeSerie*> data;
                 for(auto range : _ranges)
                 {
                   auto ds = _provider->getData(
                       DataProviderParameters{{range}, _variable->metadata()});
                   if(ds and ds->size()) data.push_back(ds); // skip empty dataSeries
                 }
                 if(_overwrite)
                   _variable->setData(data, _range, true);
                 else
                 {
                   data.push_back(_variable->data().get());
                   _variable->setData(data, _range, true);
                 }
                 std::for_each(std::begin(data), std::end(data),
                               [](TimeSeries::ITimeSerie* ts) { delete ts; });
                 emit transactionComplete();
               }
             signals:
               void transactionComplete();
             };
             class VCTransactionsQueues
             {
               QReadWriteLock _mutex{QReadWriteLock::Recursive};
               std::map<QUuid, std::optional<std::shared_ptr<VCTransaction>>>
                   _nextTransactions;
               std::map<QUuid, std::optional<std::shared_ptr<VCTransaction>>>
                   _pendingTransactions;
             public:
               void addEntry(QUuid id)
               {
                 QWriteLocker lock{&_mutex};
                 _nextTransactions[id]    = std::nullopt;
                 _pendingTransactions[id] = std::nullopt;
               }
               void removeEntry(QUuid id)
               {
                 QWriteLocker lock{&_mutex};
                 _nextTransactions.erase(id);
                 _pendingTransactions.erase(id);
               }
               std::map<QUuid, std::optional<std::shared_ptr<VCTransaction>>>
               pendingTransactions()
               {
                 QReadLocker lock{&_mutex};
                 return _pendingTransactions;
               }
               std::map<QUuid, std::optional<std::shared_ptr<VCTransaction>>>
               nextTransactions()
               {
                 QReadLocker lock{&_mutex};
                 return _nextTransactions;
               }
               std::optional<std::shared_ptr<VCTransaction>> start(QUuid id)
               {
                 QWriteLocker lock{&_mutex};
                 _pendingTransactions[id] = _nextTransactions[id];
                 _nextTransactions[id]    = std::nullopt;
                 return _pendingTransactions[id];
               }
               void enqueue(QUuid id, std::shared_ptr<VCTransaction> transaction)
               {
                 QWriteLocker lock{&_mutex};
                 _nextTransactions[id] = transaction;
               }
               void complete(QUuid id)
               {
                 QWriteLocker lock{&_mutex};
                 _pendingTransactions[id] = std::nullopt;
               }
               bool active(QUuid id)
               {
                 QReadLocker lock{&_mutex};
                 return _nextTransactions[id].has_value() ||
                        _pendingTransactions[id].has_value();
               }
             };

meson.build +3 -8

             catalogicpp_dep = dependency('catalogicpp', required : true, fallback:['catalogicpp','catalogicpp_dep'])
             pybind11_dep = dependency('pybind11', required : true, fallback:['pybind11','pybind11_dep'])
             timeseries_dep = dependency('TimeSeries', required : true, fallback:['TimeSeries','time_series_dep'])
+            cpp_utils_dep = dependency('cpp_utils', fallback:['cpp_utils','cpp_utils_dep'])
             core_moc_headers = [
-             './include/Common/containers.h',
-             './include/Common/StringUtils.h',
-             './include/Common/Numeric.h',
              './include/Common/spimpl.h',
              './include/Common/DateUtils.h',
              './include/Common/MimeTypesDef.h',
              './include/Common/SignalWaiter.h',
-             './include/Common/deprecate.h',
              './include/Common/debug.h',
              './include/Common/MetaTypes.h',
-             './include/Common/cpp_utils.h',
              './include/Common/SortUtils.h',
              './include/Data/DateTimeRangeHelper.h',
              './include/Data/ScalarTimeSerie.h',
              './include/Data/DateTimeRange.h',
              './include/Data/DataProviderParameters.h',
              './include/Data/TimeSeriesUtils.h',
              './include/Data/VectorTimeSerie.h',
              './include/Data/SqpIterator.h',
              './include/Data/IDataProvider.h',
              './include/Data/SpectrogramTimeSerie.h',
              './include/Data/MultiComponentTimeSerie.h',
              './include/Data/DataSeriesType.h',
              './include/CoreGlobal.h',
              './include/Network/NetworkController.h',
              './include/Network/Response.h',
              './include/Network/Downloader.h',
              './include/Settings/SqpSettingsDefs.h',
              './include/Settings/ISqpSettingsBindable.h',
              './include/DataSource/DataSourceController.h',
              './include/DataSource/DataSourceItem.h',
              './include/DataSource/DataSourceItemAction.h',
              './include/DataSource/DataSourceItemMergeHelper.h',
              './include/Time/TimeController.h',
              './include/PluginManager/PluginManager.h',
              './include/Version.h',
              './include/Catalogue/CatalogueController.h',
              './include/Plugin/IPlugin.h',
              './include/Variable/VariableModel2.h',
              './include/Variable/VariableController2.h',
              './include/Variable/Variable2.h',
              './include/Variable/VariableSynchronizationGroup2.h',
              './include/Variable/private/VCTransaction.h']
             core_moc_sources = ['src/Network/Downloader.cpp']
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers, moc_sources: core_moc_sources)
             core_sources = ['./src/Common/MimeTypesDef.cpp',
              './src/Common/SignalWaiter.cpp',
              './src/Common/DateUtils.cpp',
-             './src/Common/StringUtils.cpp',
              './src/Network/Downloader.cpp',
              './src/Network/NetworkController.cpp',
              './src/Settings/SqpSettingsDefs.cpp',
              './src/DataSource/DataSourceItemAction.cpp',
              './src/DataSource/DataSourceItemMergeHelper.cpp',
              './src/DataSource/DataSourceItem.cpp',
              './src/DataSource/DataSourceController.cpp',
              './src/Time/TimeController.cpp',
              './src/PluginManager/PluginManager.cpp',
              './src/Version.cpp',
              './src/Catalogue/CatalogueController.cpp',
              './src/Variable/VariableSynchronizationGroup2.cpp',
              './src/Variable/Variable2.cpp',
              './src/Variable/VariableController2.cpp',
              './src/Variable/VariableModel2.cpp']
             core_inc = include_directories(['include', 'include/Plugin'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
-                                   dependencies : [qt5core, qt5network, catalogicpp_dep, pybind11_dep, timeseries_dep],
+                                   dependencies : [qt5core, qt5network, catalogicpp_dep, pybind11_dep, timeseries_dep, cpp_utils_dep],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
-                                            dependencies : [qt5core, qt5network, catalogicpp_dep, pybind11_dep, timeseries_dep])
+                                            dependencies : [qt5core, qt5network, catalogicpp_dep, pybind11_dep, timeseries_dep, cpp_utils_dep])
             pymod = import('python')
             python3 = pymod.find_installation('python3')
             pysciqlopcore_srcs = [
              './src/pybind11_wrappers/CatalogWrappers.cpp',
              './src/pybind11_wrappers/QtWrappers.cpp',
              './src/pybind11_wrappers/CoreWrappers.cpp'
             ]
             python3.extension_module('pysciqlopcore', './src/pybind11_wrappers/CoreWrappers.cpp',
                                      dependencies: [sciqlop_core],
                                      install: true
                                     )
             subdir('tests')

src/Catalogue/CatalogueController.cpp +2 -2

             #include <Catalogue/CatalogueController.h>
             #include <CatalogueIO.hpp>
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Common/debug.h>
             #include <QDataStream>
             #include <QDir>
             #include <QMutex>
             #include <QStandardPaths>
             #include <QThread>
-            using namespace SciQLop::containers;
+            using namespace cpp_utils::containers;
             // class CatalogueController::CatalogueControllerPrivate
             //{
             // public:
             //    explicit CatalogueControllerPrivate(CatalogueController* parent) : m_Q {
             //    parent } {}
             //    CatalogueDao m_CatalogueDao;
             //    QStringList m_RepositoryList;
             //    CatalogueController* m_Q;
             //    QSet<QString> m_KeysWithChanges;
             //    QString eventUniqueKey(const std::shared_ptr<DBEvent>& event) const;
             //    QString catalogueUniqueKey(const std::shared_ptr<DBCatalogue>& catalogue)
             //    const;
             //    void copyDBtoDB(const QString& dbFrom, const QString& dbTo);
             //    QString toWorkRepository(QString repository);
             //    QString toSyncRepository(QString repository);
             //    void savAllDB();
             //    void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
             //    void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist =
             //    true);
             //    std::shared_ptr<IRequestPredicate> createFinder(
             //        const QUuid& uniqId, const QString& repository, DBType type);
             //};
             CatalogueController::CatalogueController(QObject* parent)
             //: impl { spimpl::make_unique_impl<CatalogueControllerPrivate>(this) }
             {}
             CatalogueController::~CatalogueController() {}
             QStringList CatalogueController::repositories() const
             {
               QStringList repos;
               std::transform(std::begin(_currentRepos), std::end(_currentRepos),
                              std::back_inserter(repos),
                              [](auto& pair) { return pair.first; });
               return repos;
             }
             void CatalogueController::loadRepository(const QString& path,
                                                      const QString& name)
             {
               if(QFile::exists(path))
               {
                 auto repo = CatalogiCpp::load_repository<time_t>(path.toStdString());
                 _lastSavedRepos[name] = repo;
                 _currentRepos[name]   = repo;
               }
             }
             void CatalogueController::saveRepository(const QString& path,
                                                      const QString& name)
             {
               if(contains(_currentRepos, name))
               {
                 CatalogiCpp::save_repository(_currentRepos[name], path.toStdString());
                 _lastSavedRepos[name] = _currentRepos[name];
               }
             }
             std::vector<CatalogueController::Event_ptr> CatalogueController::events()
             {
               std::vector<CatalogueController::Event_ptr> e_list;
               for(auto& [_, repo] : _currentRepos)
               {
                 for(auto& [_, event] : repo.events())
                   e_list.push_back(event);
               }
               return e_list;
             }
             std::vector<CatalogueController::Event_ptr>
             CatalogueController::events(const CatalogueController::Catalogue_ptr& catalogue)
             {
               std::vector<CatalogueController::Event_ptr> e_list;
               for(auto& [_, event] : catalogue->events())
                 e_list.push_back(event);
               return e_list;
             }
             std::vector<std::shared_ptr<CatalogueController::Event_t>>
             CatalogueController::events(const QString& repository)
             {
               std::vector<std::shared_ptr<CatalogueController::Event_t>> e_list;
               if(contains(_currentRepos, repository))
               {
                 auto repo = _currentRepos[repository];
                 for(auto& [_, event] : repo.events())
                   e_list.push_back(event);
               }
               return e_list;
             }
             std::vector<CatalogueController::Catalogue_ptr>
             CatalogueController::catalogues()
             {
               std::vector<CatalogueController::Catalogue_ptr> c_list;
               for(auto& [_, repo] : _currentRepos)
               {
                 for(auto& [_, catalogue] : repo.catalogues())
                   c_list.push_back(catalogue);
               }
               return c_list;
             }
             std::vector<CatalogueController::Catalogue_ptr>
             CatalogueController::catalogues(const QString& repository)
             {
               std::vector<CatalogueController::Catalogue_ptr> c_list;
               if(contains(_currentRepos, repository))
               {
                 auto repo = _currentRepos[repository];
                 for(auto& [_, catalogue] : repo.catalogues())
                   c_list.push_back(catalogue);
               }
               return c_list;
             }
             bool CatalogueController::hasUnsavedChanges(
                 CatalogueController::Event_ptr event)
             {
               if(auto repo = repository(event))
               {
                 if(contains(_lastSavedRepos, *repo))
                 { return *event != *(_lastSavedRepos[*repo].event(event->uuid)); }
               }
               return true;
             }
             std::optional<QString>
             CatalogueController::repository(CatalogueController::Event_ptr event)
             {
               for(auto& [repoName, repo] : _currentRepos)
               {
                 if(repo.event(event->uuid)) return repoName;
               }
               return std::nullopt;
             }
             std::optional<QString>
             CatalogueController::repository(CatalogueController::Catalogue_ptr catalogue)
             {
               for(auto& [repoName, repo] : _currentRepos)
               {
                 if(repo.catalogue(catalogue->uuid)) return repoName;
               }
               return std::nullopt;
             }
             void CatalogueController::save(CatalogueController::Event_ptr event)
             {
               auto repo_name = repository(event);
               if(repo_name && contains(_lastSavedRepos, *repo_name))
               {
                 auto repo = _lastSavedRepos[*repo_name];
                 if(contains(repo.events(), event->uuid))
                 {
                   auto saved_evemt = _lastSavedRepos[*repo_name].event(event->uuid);
                   *saved_evemt     = *event;
                 }
                 else
                 {
                   // TODO/Question should we also take care of which catalogue has it?
                   // if an event is created and added to a catalogue, what should we do if
                   // the user clicks the event save button?
                   //  - Only save event value in all events list?
                   //  - Also save the fact that this event is added to a catalogue and save
                   //    the catalogue?
                   repo.add(event);
                 }
               }
             }
             void CatalogueController::save(CatalogueController::Catalogue_ptr catalogue)
             {
               auto repo_name = repository(catalogue);
               if(repo_name && contains(_lastSavedRepos, *repo_name))
               {
                 auto repo = _lastSavedRepos[*repo_name];
                 if(contains(repo.catalogues(), catalogue->uuid))
                 {
                   auto saved_catalogue = repo.catalogue(catalogue->uuid);
                   *saved_catalogue     = *catalogue;
                 }
                 else
                 {
                   repo.add(catalogue);
                 }
               }
             }
             void CatalogueController::save(const QString& repository)
             {
               if(contains(_currentRepos, repository))
               { _lastSavedRepos[repository] = _currentRepos[repository]; }
               else
               {
                 SCIQLOP_ERROR(CatalogueController, "Trying to save an unknown repository");
               }
             }
             void CatalogueController::add(const QString& repository)
             {
               if(!contains(_currentRepos, repository))
               {
                 _currentRepos[repository] = Repository_t{};
                 emit repositoryAdded(repository);
               }
             }
             CatalogueController::Catalogue_ptr
             CatalogueController::add(const QString& catalogue, const QString& repository)
             {
               if(!contains(_currentRepos, repository)) { add(repository); }
               auto new_catalogue  = make_catalogue_ptr();
               new_catalogue->name = catalogue.toStdString();
               _currentRepos[repository].add(new_catalogue);
               emit catalogueAdded(new_catalogue, repository);
               return new_catalogue;
             }
             void CatalogueController::add(CatalogueController::Event_ptr event,
                                           CatalogueController::Catalogue_ptr catalogue)
             {
               catalogue->add(event);
               emit this->catalogueChanged(catalogue);
             }
             void CatalogueController::add(CatalogueController::Event_ptr event,
                                           const QString& repository)
             {}
             // void CatalogueController::saveDB(const QString& destinationPath, const
             // QString& repositoryName)
             //{
             //    if (!impl->m_CatalogueDao.saveDB(destinationPath, repositoryName))
             //    {
             //        qCCritical(LOG_CatalogueController())
             //            << tr("Impossible to saveDB %1 from %2 ").arg(repositoryName,
             //            destinationPath);
             //    }
             //}
             // std::list<std::shared_ptr<DBEvent>> CatalogueController::retrieveEvents(
             //    const QString& repository) const
             //{
             //    QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT :
             //    repository;
             //    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
             //    auto events =
             //    impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName)); for
             //    (auto event : events)
             //    {
             //        eventsShared.push_back(std::make_shared<DBEvent>(event));
             //    }
             //    return eventsShared;
             //}
             // std::list<std::shared_ptr<DBEvent>> CatalogueController::retrieveAllEvents()
             // const
             //{
             //    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
             //    for (auto repository : impl->m_RepositoryList)
             //    {
             //        eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
             //    }
             //    return eventsShared;
             //}
             // std::list<std::shared_ptr<DBEvent>>
             // CatalogueController::retrieveEventsFromCatalogue(
             //    std::shared_ptr<DBCatalogue> catalogue) const
             //{
             //    auto eventsShared = std::list<std::shared_ptr<DBEvent>> {};
             //    auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
             //    for (auto event : events)
             //    {
             //        eventsShared.push_back(std::make_shared<DBEvent>(event));
             //    }
             //    return eventsShared;
             //}
             // void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
             //{
             //    event->setRepository(impl->toWorkRepository(event->getRepository()));
             //    auto uniqueId = impl->eventUniqueKey(event);
             //    impl->m_KeysWithChanges.insert(uniqueId);
             //    impl->m_CatalogueDao.updateEvent(*event);
             //}
             // void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct>
             // eventProduct)
             //{
             //    impl->m_CatalogueDao.updateEventProduct(*eventProduct);
             //}
             // void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
             //{
             //    // Remove it from both repository and repository_work
             //    event->setRepository(impl->toWorkRepository(event->getRepository()));
             //    impl->m_CatalogueDao.removeEvent(*event);
             //    event->setRepository(impl->toSyncRepository(event->getRepository()));
             //    impl->m_CatalogueDao.removeEvent(*event);
             //    impl->savAllDB();
             //}
             // void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             //{
             //    event->setRepository(impl->toWorkRepository(event->getRepository()));
             //    auto eventTemp = *event;
             //    impl->m_CatalogueDao.addEvent(eventTemp);
             //    // Call update is necessary at the creation of add Event if it has some
             //    tags or some event
             //    // products
             //    if (!event->getEventProducts().empty() || !event->getTags().empty())
             //    {
             //        auto eventProductsTemp = eventTemp.getEventProducts();
             //        auto eventProductTempUpdated = std::list<DBEventProduct> {};
             //        for (auto eventProductTemp : eventProductsTemp)
             //        {
             //            eventProductTemp.setEvent(eventTemp);
             //            eventProductTempUpdated.push_back(eventProductTemp);
             //        }
             //        eventTemp.setEventProducts(eventProductTempUpdated);
             //        impl->m_CatalogueDao.updateEvent(eventTemp);
             //    }
             //    auto workPred = impl->createFinder(event->getUniqId(),
             //    event->getRepository(), DBType::WORK);
             //    auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
             //    *event = workEvent;
             //    auto uniqueId = impl->eventUniqueKey(event);
             //    impl->m_KeysWithChanges.insert(uniqueId);
             //}
             // void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             //{
             //    impl->saveEvent(event, true);
             //    impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
             //}
             // void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool&
             // removed)
             //{
             //    auto syncPred = impl->createFinder(event->getUniqId(),
             //    event->getRepository(), DBType::SYNC); auto workPred =
             //    impl->createFinder(event->getUniqId(), event->getRepository(),
             //    DBType::WORK);
             //    auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
             //    if (!syncEvent.getUniqId().isNull())
             //    {
             //        removed = false;
             //        impl->m_CatalogueDao.copyEvent(
             //            syncEvent, impl->toWorkRepository(event->getRepository()), true);
             //        auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
             //        *event = workEvent;
             //        impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
             //    }
             //    else
             //    {
             //        removed = true;
             //        // Since the element wasn't in sync repository. Discard it means
             //        remove it
             //        event->setRepository(impl->toWorkRepository(event->getRepository()));
             //        impl->m_CatalogueDao.removeEvent(*event);
             //    }
             //}
             // bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event)
             // const
             //{
             //    return impl->m_KeysWithChanges.contains(impl->eventUniqueKey(event));
             //}
             // std::list<std::shared_ptr<DBCatalogue>>
             // CatalogueController::retrieveCatalogues(
             //    const QString& repository) const
             //{
             //    QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT :
             //    repository;
             //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue>> {};
             //    auto catalogues =
             //    impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
             //    for (auto catalogue : catalogues)
             //    {
             //        cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
             //    }
             //    return cataloguesShared;
             //}
             // void CatalogueController::addCatalogue(std::shared_ptr<DBCatalogue>
             // catalogue)
             //{
             //    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
             //    auto catalogueTemp = *catalogue;
             //    impl->m_CatalogueDao.addCatalogue(catalogueTemp);
             //    auto workPred
             //        = impl->createFinder(catalogue->getUniqId(),
             //        catalogue->getRepository(), DBType::WORK);
             //    auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
             //    *catalogue = workCatalogue;
             //    auto uniqueId = impl->catalogueUniqueKey(catalogue);
             //    impl->m_KeysWithChanges.insert(uniqueId);
             //}
             // void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue>
             // catalogue)
             //{
             //    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
             //    auto uniqueId = impl->catalogueUniqueKey(catalogue);
             //    impl->m_KeysWithChanges.insert(uniqueId);
             //    impl->m_CatalogueDao.updateCatalogue(*catalogue);
             //}
             // void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue>
             // catalogue)
             //{
             //    // Remove it from both repository and repository_work
             //    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
             //    impl->m_CatalogueDao.removeCatalogue(*catalogue);
             //    catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
             //    impl->m_CatalogueDao.removeCatalogue(*catalogue);
             //    impl->savAllDB();
             //}
             // void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue>
             // catalogue)
             //{
             //    impl->saveCatalogue(catalogue, true);
             //    impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
             //    // remove key of events of the catalogue
             //    if (catalogue->getType() == CatalogueType::STATIC)
             //    {
             //        auto events = this->retrieveEventsFromCatalogue(catalogue);
             //        for (auto event : events)
             //        {
             //            impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
             //        }
             //    }
             //}
             // void CatalogueController::discardCatalogue(std::shared_ptr<DBCatalogue>
             // catalogue, bool& removed)
             //{
             //    auto syncPred
             //        = impl->createFinder(catalogue->getUniqId(),
             //        catalogue->getRepository(), DBType::SYNC);
             //    auto workPred
             //        = impl->createFinder(catalogue->getUniqId(),
             //        catalogue->getRepository(), DBType::WORK);
             //    auto syncCatalogue = impl->m_CatalogueDao.getCatalogue(syncPred);
             //    if (!syncCatalogue.getUniqId().isNull())
             //    {
             //        removed = false;
             //        impl->m_CatalogueDao.copyCatalogue(
             //            syncCatalogue, impl->toWorkRepository(catalogue->getRepository()),
             //            true);
             //        auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
             //        *catalogue = workCatalogue;
             //        impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
             //    }
             //    else
             //    {
             //        removed = true;
             //        // Since the element wasn't in sync repository. Discard it means
             //        remove it
             //        catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
             //        impl->m_CatalogueDao.removeCatalogue(*catalogue);
             //    }
             //}
             // void CatalogueController::saveAll()
             //{
             //    for (auto repository : impl->m_RepositoryList)
             //    {
             //        // Save Event
             //        auto events = this->retrieveEvents(repository);
             //        for (auto event : events)
             //        {
             //            impl->saveEvent(event, false);
             //        }
             //        // Save Catalogue
             //        auto catalogues = this->retrieveCatalogues(repository);
             //        for (auto catalogue : catalogues)
             //        {
             //            impl->saveCatalogue(catalogue, false);
             //        }
             //    }
             //    impl->savAllDB();
             //    impl->m_KeysWithChanges.clear();
             //}
             // bool CatalogueController::hasChanges() const
             //{
             //    return !impl->m_KeysWithChanges.isEmpty();
             //}
             // QByteArray CatalogueController::mimeDataForEvents(
             //    const QVector<std::shared_ptr<DBEvent>>& events) const
             //{
             //    auto encodedData = QByteArray {};
             //    QMap<QString, QVariantList> idsPerRepository;
             //    for (auto event : events)
             //    {
             //        idsPerRepository[event->getRepository()] << event->getUniqId();
             //    }
             //    QDataStream stream { &encodedData, QIODevice::WriteOnly };
             //    stream << idsPerRepository;
             //    return encodedData;
             //}
             // QVector<std::shared_ptr<DBEvent>> CatalogueController::eventsForMimeData(
             //    const QByteArray& mimeData) const
             //{
             //    auto events = QVector<std::shared_ptr<DBEvent>> {};
             //    QDataStream stream { mimeData };
             //    QMap<QString, QVariantList> idsPerRepository;
             //    stream >> idsPerRepository;
             //    for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend();
             //    ++it)
             //    {
             //        auto repository = it.key();
             //        auto allRepositoryEvent = retrieveEvents(repository);
             //        for (auto uuid : it.value())
             //        {
             //            for (auto repositoryEvent : allRepositoryEvent)
             //            {
             //                if (uuid.toUuid() == repositoryEvent->getUniqId())
             //                {
             //                    events << repositoryEvent;
             //                }
             //            }
             //        }
             //    }
             //    return events;
             //}
             // QByteArray CatalogueController::mimeDataForCatalogues(
             //    const QVector<std::shared_ptr<DBCatalogue>>& catalogues) const
             //{
             //    auto encodedData = QByteArray {};
             //    QMap<QString, QVariantList> idsPerRepository;
             //    for (auto catalogue : catalogues)
             //    {
             //        idsPerRepository[catalogue->getRepository()] <<
             //        catalogue->getUniqId();
             //    }
             //    QDataStream stream { &encodedData, QIODevice::WriteOnly };
             //    stream << idsPerRepository;
             //    return encodedData;
             //}
             // QVector<std::shared_ptr<DBCatalogue>>
             // CatalogueController::cataloguesForMimeData(
             //    const QByteArray& mimeData) const
             //{
             //    auto catalogues = QVector<std::shared_ptr<DBCatalogue>> {};
             //    QDataStream stream { mimeData };
             //    QMap<QString, QVariantList> idsPerRepository;
             //    stream >> idsPerRepository;
             //    for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend();
             //    ++it)
             //    {
             //        auto repository = it.key();
             //        auto allRepositoryCatalogues = retrieveCatalogues(repository);
             //        for (auto uuid : it.value())
             //        {
             //            for (auto repositoryCatalogues : allRepositoryCatalogues)
             //            {
             //                if (uuid.toUuid() == repositoryCatalogues->getUniqId())
             //                {
             //                    catalogues << repositoryCatalogues;
             //                }
             //            }
             //        }
             //    }
             //    return catalogues;
             //}
             // void CatalogueController::initialize()
             //{
             //    qCDebug(LOG_CatalogueController())
             //        << tr("CatalogueController init") << QThread::currentThread();
             //    impl->m_CatalogueDao.initialize();
             //    auto defaultRepositoryLocation
             //        = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
             //    QDir defaultRepositoryLocationDir;
             //    if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation))
             //    {
             //        defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
             //        auto defaultRepository =
             //        defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
             //        qCInfo(LOG_CatalogueController())
             //            << tr("Persistant data loading from: ") << defaultRepository;
             //        QDir dbDir(defaultRepository);
             //        impl->m_RepositoryList << REPOSITORY_DEFAULT;
             //        if (dbDir.exists())
             //        {
             //            auto dirName = dbDir.dirName();
             //            if (impl->m_CatalogueDao.addDB(defaultRepository, dirName))
             //            {
             //                impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
             //            }
             //        }
             //        else
             //        {
             //            qCInfo(LOG_CatalogueController())
             //                << tr("Initialisation of Default repository detected") <<
             //                defaultRepository;
             //        }
             //    }
             //    else
             //    {
             //        qCWarning(LOG_CatalogueController())
             //            << tr("Cannot load the persistent default repository from ")
             //            << defaultRepositoryLocation;
             //    }
             //    qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             //}
             // QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
             //    const std::shared_ptr<DBEvent>& event) const
             //{
             //    return event->getUniqId().toString().append(event->getRepository());
             //}
             // QString CatalogueController::CatalogueControllerPrivate::catalogueUniqueKey(
             //    const std::shared_ptr<DBCatalogue>& catalogue) const
             //{
             //    return
             //    catalogue->getUniqId().toString().append(catalogue->getRepository());
             //}
             // void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(
             //    const QString& dbFrom, const QString& dbTo)
             //{
             //    //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
             //    auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
             //    auto events = m_CatalogueDao.getEvents(dbFrom);
             //    for (auto catalogue : catalogues)
             //    {
             //        m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
             //    }
             //    for (auto event : events)
             //    {
             //        m_CatalogueDao.copyEvent(event, dbTo, true);
             //    }
             //}
             // QString
             // CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString
             // repository)
             //{
             //    auto syncRepository = toSyncRepository(repository);
             //    return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
             //}
             // QString
             // CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString
             // repository)
             //{
             //    auto syncRepository = repository;
             //    if (repository.endsWith(REPOSITORY_WORK_SUFFIX))
             //    {
             //        syncRepository.remove(REPOSITORY_WORK_SUFFIX);
             //    }
             //    else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX))
             //    {
             //        syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
             //    }
             //    return syncRepository;
             //}
             // void CatalogueController::CatalogueControllerPrivate::savAllDB()
             //{
             //    for (auto repository : m_RepositoryList)
             //    {
             //        auto defaultRepositoryLocation
             //            =
             //            QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
             //        m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
             //    }
             //}
             // void CatalogueController::CatalogueControllerPrivate::saveEvent(
             //    std::shared_ptr<DBEvent> event, bool persist)
             //{
             //    m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()),
             //    true); if (persist)
             //    {
             //        savAllDB();
             //    }
             //}
             // void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
             //    std::shared_ptr<DBCatalogue> catalogue, bool persist)
             //{
             //    m_CatalogueDao.copyCatalogue(*catalogue,
             //    toSyncRepository(catalogue->getRepository()), true); if (persist)
             //    {
             //        savAllDB();
             //    }
             //}
             // std::shared_ptr<IRequestPredicate>
             // CatalogueController::CatalogueControllerPrivate::createFinder(
             //    const QUuid& uniqId, const QString& repository, DBType type)
             //{
             //    // update catalogue parameter
             //    auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
             //        QString { "uniqId" }, uniqId, ComparaisonOperation::EQUALEQUAL);
             //    auto repositoryType = repository;
             //    switch (type)
             //    {
             //        case DBType::SYNC:
             //            repositoryType = toSyncRepository(repositoryType);
             //            break;
             //        case DBType::WORK:
             //            repositoryType = toWorkRepository(repositoryType);
             //            break;
             //        case DBType::TRASH:
             //        default:
             //            break;
             //    }
             //    auto repositoryPredicate = std::make_shared<ComparaisonPredicate>(
             //        QString { "repository" }, repositoryType,
             //        ComparaisonOperation::EQUALEQUAL);
             //    auto finderPred =
             //    std::make_shared<CompoundPredicate>(CompoundOperation::AND);
             //    finderPred->AddRequestPredicate(uniqIdPredicate);
             //    finderPred->AddRequestPredicate(repositoryPredicate);
             //    return finderPred;
             //}

src/DataSource/DataSourceController.cpp +1 -1

             #include "DataSource/DataSourceController.h"
             #include "DataSource/DataSourceItem.h"
             #include "DataSource/DataSourceItemAction.h"
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Data/IDataProvider.h>
             #include <QDataStream>
             #include <QDir>
             #include <QMutex>
             #include <QStandardPaths>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             std::unique_ptr<DataSourceItem> make_folder_item(const QString& name)
             {
               return std::make_unique<DataSourceItem>(DataSourceItemType::NODE, name);
             }
             template<typename T>
             DataSourceItem* make_path_items(const T& path_list_begin,
                                             const T& path_list_end, DataSourceItem* root)
             {
               std::for_each(path_list_begin, path_list_end,
                             [&root](const auto& folder_name) mutable {
                               auto folder_ptr = root->findItem(folder_name);
                               if(folder_ptr == nullptr)
                               {
                                 auto folder = make_folder_item(folder_name);
                                 folder_ptr  = folder.get();
                                 root->appendChild(std::move(folder));
                               }
                               root = folder_ptr;
                             });
               return root;
             }
             std::unique_ptr<DataSourceItem>
             make_product_item(const QVariantHash& metaData, const QUuid& dataSourceUid,
                               const QString& DATA_SOURCE_NAME, DataSourceController* dc)
             {
               auto result =
                   std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, metaData);
               // Adds plugin name to product metadata
               result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
               result->setData(DataSourceItem::ID_DATA_KEY,
                               metaData.value(DataSourceItem::NAME_DATA_KEY));
               auto productName = metaData.value(DataSourceItem::NAME_DATA_KEY).toString();
               // Add action to load product from DataSourceController
               result->addAction(std::make_unique<DataSourceItemAction>(
                   QObject::tr("Load %1 product").arg(productName),
                   [productName, dataSourceUid, dc](DataSourceItem& item) {
                     if(dc) { dc->loadProductItem(dataSourceUid, item); }
                   }));
               return result;
             }
             class DataSourceController::DataSourceControllerPrivate
             {
             public:
               QMutex m_WorkingMutex;
               /// Data sources registered
               QHash<QUuid, QString> m_DataSources;
               /// Data sources structures
               std::map<QUuid, std::unique_ptr<DataSourceItem>> m_DataSourceItems;
               /// Data providers registered
               /// @remarks Data providers are stored as shared_ptr as they can be sent to a
               /// variable and continue to live without necessarily the data source
               /// controller
               std::map<QUuid, std::shared_ptr<IDataProvider>> m_DataProviders;
               // Search for the first datasource item matching the specified data
               DataSourceItem* findDataSourceItem(const QVariantHash& data)
               {
                 DataSourceItem* sourceItem = nullptr;
                 for(const auto& item : m_DataSourceItems)
                 {
                   sourceItem = item.second->findItem(data, true);
                   if(sourceItem) { break; }
                 }
                 return sourceItem;
               }
               // Search for the first datasource item matching the specified ID_DATA_KEY
               DataSourceItem* findDataSourceItem(const QString& datasourceIdKey)
               {
                 DataSourceItem* sourceItem = nullptr;
                 for(const auto& item : m_DataSourceItems)
                 {
                   sourceItem = item.second->findItem(datasourceIdKey, true);
                   if(sourceItem) { break; }
                 }
                 return sourceItem;
               }
             };
             DataSourceController::DataSourceController(QObject* parent)
                 : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
               qCDebug(LOG_DataSourceController())
                   << tr("DataSourceController construction") << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
               qCDebug(LOG_DataSourceController())
                   << tr("DataSourceController destruction") << QThread::currentThread();
               this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(
                 const QString& dataSourceName) noexcept
             {
               auto dataSourceUid = QUuid::createUuid();
               impl->m_DataSources.insert(dataSourceUid, dataSourceName);
               return dataSourceUid;
             }
             void DataSourceController::registerProvider(IDataProvider *provider) noexcept
             {
               impl->m_DataSources.insert(provider->id(), provider->name());
               impl->m_DataProviders.insert({provider->id(), std::unique_ptr<IDataProvider>{provider}});
               // TODO rethink this, I don't get why we have to do this crap
               // why do we need a root node for each provider
               setDataSourceItem(provider->id(),make_folder_item(provider->name()));
             }
             void DataSourceController::setDataSourceItem(
                 const QUuid& dataSourceUid,
                 std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
               if(!dataSourceItem)
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("Data source item can't be registered (null item)");
                 return;
               }
               if(impl->m_DataSources.contains(dataSourceUid))
               {
                 // The data provider is implicitly converted to a shared_ptr
                 impl->m_DataSourceItems.insert(
                     std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                 // Retrieves the data source item to emit the signal with it
                 auto it = impl->m_DataSourceItems.find(dataSourceUid);
                 if(it != impl->m_DataSourceItems.end())
                 { emit dataSourceItemSet(it->second.get()); }
               }
               else
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("Can't set data source item for uid %1 : no "
                           "data source has been registered with the uid")
                            .arg(dataSourceUid.toString());
               }
             }
             void DataSourceController::setDataSourceItem(const QUuid& dataSourceUid, const QString& path,
                 const QMap<QString, QString> &metaData) noexcept
             {
               if(auto it = impl->m_DataSourceItems.find(dataSourceUid);
                  it != impl->m_DataSourceItems.end())
               {
                 auto path_list = path.split('/', QString::SkipEmptyParts);
                 auto name      = *(std::cend(path_list) - 1);
                 auto path_item = make_path_items(
                     std::cbegin(path_list), std::cend(path_list) - 1, it->second.get());
                 QVariantHash meta_data{{DataSourceItem::NAME_DATA_KEY, name}};
                 for(auto& key : metaData.keys())
                 {
                   meta_data[key] = metaData[key];
                 }
                 path_item->appendChild(
                     make_product_item(meta_data, dataSourceUid, "test", this));
                 emit dataSourceItemSet(it->second.get());
               }
             }
             void DataSourceController::setDataProvider(
                 const QUuid& dataSourceUid,
                 std::unique_ptr<IDataProvider> dataProvider) noexcept
             {
               if(impl->m_DataSources.contains(dataSourceUid))
               {
                 impl->m_DataProviders.insert(
                     std::make_pair(dataSourceUid, std::move(dataProvider)));
               }
               else
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("Can't set data provider for uid %1 : no data "
                           "source has been registered with the uid")
                            .arg(dataSourceUid.toString());
               }
             }
             void DataSourceController::loadProductItem(
                 const QUuid& dataSourceUid, const DataSourceItem& productItem) noexcept
             {
               if(productItem.type() == DataSourceItemType::PRODUCT ||
                  productItem.type() == DataSourceItemType::COMPONENT)
               {
                 /// Retrieves the data provider of the data source (if any)
                 auto it = impl->m_DataProviders.find(dataSourceUid);
                 auto dataProvider =
                     (it != impl->m_DataProviders.end()) ? it->second : nullptr;
                 emit createVariable(productItem.name(), productItem.data(), dataProvider);
               }
               else
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("Can't load an item that is not a product");
               }
             }
             QByteArray
             DataSourceController::mimeDataForProductsData(const QVariantList& productsData)
             {
               QByteArray encodedData;
               QDataStream stream{&encodedData, QIODevice::WriteOnly};
               stream << productsData;
               return encodedData;
             }
             QVariantList
             DataSourceController::productsDataForMimeData(const QByteArray& mimeData)
             {
               QDataStream stream{mimeData};
               QVariantList productList;
               stream >> productList;
               return productList;
             }
             void DataSourceController::initialize()
             {
               qCDebug(LOG_DataSourceController())
                   << tr("DataSourceController init") << QThread::currentThread();
               impl->m_WorkingMutex.lock();
               qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize() { impl->m_WorkingMutex.unlock(); }
             void DataSourceController::requestVariableFromProductIdKey(
                 const QString& datasourceIdKey)
             {
               auto sourceItem = impl->findDataSourceItem(datasourceIdKey);
               if(sourceItem)
               {
                 auto sourceName = sourceItem->rootItem().name();
                 auto sourceId   = impl->m_DataSources.key(sourceName);
                 loadProductItem(sourceId, *sourceItem);
               }
               else
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("requestVariable, product data not found");
               }
             }
             void DataSourceController::requestVariable(const QVariantHash& productData)
             {
               auto sourceItem = impl->findDataSourceItem(productData);
               if(sourceItem)
               {
                 auto sourceName = sourceItem->rootItem().name();
                 auto sourceId   = impl->m_DataSources.key(sourceName);
                 loadProductItem(sourceId, *sourceItem);
               }
               else
               {
                 qCWarning(LOG_DataSourceController())
                     << tr("requestVariable, product data not found");
               }
             }
             void DataSourceController::waitForFinish()
             {
               QMutexLocker locker{&impl->m_WorkingMutex};
             }

src/Variable/VariableController2.cpp +2 -2

             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <QCoreApplication>
             #include <QDataStream>
             #include <QObject>
             #include <QQueue>
             #include <QRunnable>
             #include <QThreadPool>
             #include <Variable/private/VCTransaction.h>
             class VariableController2::VariableController2Private
             {
               struct threadSafeVaraiblesMaps
               {
                 inline void
                 addVariable(const std::shared_ptr<Variable2>& variable,
                             const std::shared_ptr<IDataProvider>& provider,
                             const std::shared_ptr<VariableSynchronizationGroup2>&
                                 synchronizationGroup)
                 {
                   QWriteLocker lock{&_lock};
                   _variables[*variable]             = variable;
                   _providers[*variable]             = provider;
                   _synchronizationGroups[*variable] = synchronizationGroup;
                 }
                 inline void removeVariable(const std::shared_ptr<Variable2>& variable)
                 {
                   QWriteLocker lock{&_lock};
                   _variables.erase(*variable);
                   _providers.remove(*variable);
                   _synchronizationGroups.remove(*variable);
                 }
                 inline void
                 synchronize(const std::shared_ptr<Variable2>& variable,
                             const std::optional<std::shared_ptr<Variable2>>& with)
                 {
                   QWriteLocker lock{&_lock};
                   if(with.has_value())
                   {
                     auto newGroup = _synchronizationGroups[*with.value()];
                     newGroup->addVariable(*variable);
                     _synchronizationGroups[*variable] = newGroup;
                   }
                   else
                   {
                     _synchronizationGroups[*variable] =
                         std::make_shared<VariableSynchronizationGroup2>(*variable);
                   }
                 }
                 inline std::shared_ptr<Variable2> variable(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
                   auto it = _variables.find(variable);
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(it == _variables.end())
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return (*it).second;
                 }
                 inline std::shared_ptr<Variable2> variable(int index)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
-                  if(!_variables.size() > index)
+                  if(!(_variables.size() > static_cast<unsigned int>(index)))
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Index is out of bounds");
                   auto it = _variables.cbegin();
                   while(index != 0)
                   {
                     index -= 1;
                     it++;
                   }
                   return (*(it)).second;
                 }
                 inline const std::vector<std::shared_ptr<Variable2>> variables()
                 {
                   std::vector<std::shared_ptr<Variable2>> vars;
                   QReadLocker lock{&_lock};
                   for(const auto& [id, var] : _variables)
                   {
                     vars.push_back(var);
                   }
                   return vars;
                 }
                 inline std::shared_ptr<IDataProvider> provider(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(!_providers.contains(variable))
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return _providers[variable];
                 }
                 inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(!_synchronizationGroups.contains(variable))
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return _synchronizationGroups[variable];
                 }
                 inline bool has(const std::shared_ptr<Variable2>& variable)
                 {
                   QReadLocker lock{&_lock};
                   return _variables.find(*variable) == _variables.end();
                 }
               private:
                 std::map<QUuid, std::shared_ptr<Variable2>> _variables;
                 QMap<QUuid, std::shared_ptr<IDataProvider>> _providers;
                 QMap<QUuid, std::shared_ptr<VariableSynchronizationGroup2>>
                     _synchronizationGroups;
                 QReadWriteLock _lock{QReadWriteLock::Recursive};
               } _maps;
               std::vector<QUuid> _variablesToRemove;
               QThreadPool* _ThreadPool;
               VCTransactionsQueues _transactions;
               void _transactionComplete(QUuid group,
                                         std::shared_ptr<VCTransaction> transaction)
               {
                 if(transaction->done()) { _transactions.complete(group); }
                 this->_processTransactions();
               }
               void _cleanupVariables()
               {
                 for(auto id : _variablesToRemove)
                 {
                   auto v = this->variable(id);
                   if(!hasPendingTransactions(v))
                   {
                     _variablesToRemove.erase(std::remove(_variablesToRemove.begin(),
                                                          _variablesToRemove.end(), id),
                                              _variablesToRemove.end());
                     this->deleteVariable(v);
                   }
                 }
               }
               void _processTransactions(bool fragmented = false)
               {
                 auto nextTransactions    = _transactions.nextTransactions();
                 auto pendingTransactions = _transactions.pendingTransactions();
                 for(auto [groupID, newTransaction] : nextTransactions)
                 {
                   if(newTransaction.has_value() &&
                      !pendingTransactions[groupID].has_value())
                   {
                     _transactions.start(groupID);
                     auto refVar = _maps.variable(newTransaction.value()->refVar);
                     auto ranges =
                         _computeAllRangesInGroup(refVar, newTransaction.value()->range);
                     for(auto const& [ID, range] : ranges)
                     {
                       auto provider = _maps.provider(ID);
                       auto variable = _maps.variable(ID);
                       if(fragmented)
                       {
                         auto missingRanges = _computeMissingRanges(variable, range);
                         auto exe =
                             new TransactionExe(variable, provider, missingRanges, range);
                         QObject::connect(
                             exe, &TransactionExe::transactionComplete,
                             [groupID = groupID, transaction = newTransaction.value(),
                              this]() { this->_transactionComplete(groupID, transaction); });
                         _ThreadPool->start(exe);
                       }
                       else
                       {
                         auto exe = new TransactionExe(variable, provider, {range}, range);
                         QObject::connect(
                             exe, &TransactionExe::transactionComplete,
                             [groupID = groupID, transaction = newTransaction.value(),
                              this]() { this->_transactionComplete(groupID, transaction); });
                         _ThreadPool->start(exe);
                       }
                     }
                   }
                 }
                 // after each transaction update we get a new distribution of idle and
                 // working variables so we can delete variables which are waiting to be
                 // deleted if they are now idle
                 _cleanupVariables();
               }
               std::map<QUuid, DateTimeRange>
               _computeAllRangesInGroup(const std::shared_ptr<Variable2>& refVar,
                                        DateTimeRange r)
               {
                 std::map<QUuid, DateTimeRange> ranges;
                 if(!DateTimeRangeHelper::hasnan(r))
                 {
                   auto group = _maps.group(*refVar);
                   if(auto transformation =
                          DateTimeRangeHelper::computeTransformation(refVar->range(), r);
                      transformation.has_value())
                   {
                     for(auto varId : group->variables())
                     {
                       auto var      = _maps.variable(varId);
                       auto newRange = var->range().transform(transformation.value());
                       ranges[varId] = newRange;
                     }
                   }
                   else // force new range to all variables -> may be weird if more than one
                        // var in the group
                        // TODO ensure that there is no side effects
                   {
                     for(auto varId : group->variables())
                     {
                       auto var      = _maps.variable(varId);
                       ranges[varId] = r;
                     }
                   }
                 }
                 else
                 {
                   SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                 }
                 return ranges;
               }
               std::vector<DateTimeRange>
               _computeMissingRanges(const std::shared_ptr<Variable2>& var, DateTimeRange r)
               {
                 return r - var->range();
               }
               void _changeRange(QUuid id, DateTimeRange r)
               {
                 _changeRange(_maps.variable(id), r);
               }
               void _changeRange(const std::shared_ptr<Variable2>& var, DateTimeRange r)
               {
                 auto provider      = _maps.provider(*var);
                 auto missingRanges = _computeMissingRanges(var, r);
                 std::vector<TimeSeries::ITimeSerie*> data;
                 for(auto range : missingRanges)
                 {
                   data.push_back(
                       provider->getData(DataProviderParameters{{range}, var->metadata()}));
                 }
                 data.push_back(var->data().get()); // might be smarter
                 var->setData(data, r, true);
                 std::for_each(std::begin(data), std::end(data), [](auto ts) { delete ts; });
               }
             public:
               VariableController2Private(QObject* parent = Q_NULLPTR)
               {
                 Q_UNUSED(parent);
                 this->_ThreadPool = new QThreadPool();
                 this->_ThreadPool->setMaxThreadCount(32);
               }
               /*
                * This dtor has to like this even if this is ugly, because default dtor would
                * rely on declaration order to destruct members and that would always lead to
                * regressions when modifying class members
                */
               ~VariableController2Private() { delete this->_ThreadPool; }
               std::shared_ptr<Variable2>
               createVariable(const QString& name, const QVariantHash& metadata,
                              std::shared_ptr<IDataProvider> provider)
               {
                 auto newVar = std::make_shared<Variable2>(name, metadata);
                 auto group  = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                 _maps.addVariable(newVar, std::move(provider), group);
                 this->_transactions.addEntry(*group);
                 return newVar;
               }
               std::shared_ptr<Variable2> variable(QUuid ID) { return _maps.variable(ID); }
               std::shared_ptr<Variable2> variable(int index)
               {
                 return _maps.variable(index);
               }
               std::shared_ptr<Variable2>
               cloneVariable(const std::shared_ptr<Variable2>& variable)
               {
                 auto newVar = variable->clone();
                 _maps.synchronize(newVar, std::nullopt);
                 _maps.addVariable(newVar, _maps.provider(*variable), _maps.group(*newVar));
                 this->_transactions.addEntry(*_maps.group(*newVar));
                 return newVar;
               }
               bool hasPendingTransactions(const std::shared_ptr<Variable2>& variable)
               {
                 return _transactions.active(*_maps.group(*variable));
               }
               bool hasPendingTransactions()
               {
                 bool has = false;
                 for(const auto& var : _maps.variables())
                 {
                   has |= _transactions.active(*_maps.group(*var));
                 }
                 return has;
               }
               void deleteVariable(const std::shared_ptr<Variable2>& variable)
               {
                 if(!hasPendingTransactions(variable))
                   _maps.removeVariable(variable);
                 else
                   _variablesToRemove.push_back(variable->ID());
               }
               void asyncChangeRange(const std::shared_ptr<Variable2>& variable,
                                     const DateTimeRange& r)
               {
                 if(!DateTimeRangeHelper::hasnan(r))
                 {
                   auto group = _maps.group(*variable);
                   // Just overwrite next transaction
                   {
                     _transactions.enqueue(*group,
                                           std::make_shared<VCTransaction>(
                                               variable->ID(), r,
                                               static_cast<int>(group->variables().size())));
                   }
                   _processTransactions();
                 }
                 else
                 {
                   SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                 }
               }
               void changeRange(const std::shared_ptr<Variable2>& variable, DateTimeRange r)
               {
                 asyncChangeRange(variable, r);
                 while(hasPendingTransactions(variable))
                 {
                   QCoreApplication::processEvents();
                 }
               }
               inline void synchronize(const std::shared_ptr<Variable2>& var,
                                       const std::shared_ptr<Variable2>& with)
               {
                 _maps.synchronize(var, with);
               }
               inline const std::vector<std::shared_ptr<Variable2>> variables()
               {
                 return _maps.variables();
               }
             };
             VariableController2::VariableController2()
                 : impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable2> VariableController2::createVariable(
                 const QString& name, const QVariantHash& metadata,
                 const std::shared_ptr<IDataProvider>& provider, const DateTimeRange& range)
             {
               auto var = impl->createVariable(name, metadata, provider);
               var->setRange(range); // even with no data this is it's range
               if(!DateTimeRangeHelper::hasnan(range))
                 impl->asyncChangeRange(var, range);
               else
                 SCIQLOP_ERROR(VariableController2, "Creating a variable with default "
                                                    "constructed DateTimeRange is an error");
               emit variableAdded(var);
               return var;
             }
             std::shared_ptr<Variable2>
             VariableController2::cloneVariable(const std::shared_ptr<Variable2>& variable)
             {
               return impl->cloneVariable(variable);
             }
             void VariableController2::deleteVariable(
                 const std::shared_ptr<Variable2>& variable)
             {
               impl->deleteVariable(variable);
               emit variableDeleted(variable);
             }
             void VariableController2::changeRange(
                 const std::shared_ptr<Variable2>& variable, const DateTimeRange& r)
             {
               impl->changeRange(variable, r);
             }
             void VariableController2::asyncChangeRange(
                 const std::shared_ptr<Variable2>& variable, const DateTimeRange& r)
             {
               impl->asyncChangeRange(variable, r);
             }
             const std::vector<std::shared_ptr<Variable2>> VariableController2::variables()
             {
               return impl->variables();
             }
             bool VariableController2::isReady(const std::shared_ptr<Variable2>& variable)
             {
               return !impl->hasPendingTransactions(variable);
             }
             bool VariableController2::isReady() { return !impl->hasPendingTransactions(); }
             void VariableController2::synchronize(const std::shared_ptr<Variable2>& var,
                                                   const std::shared_ptr<Variable2>& with)
             {
               impl->synchronize(var, with);
             }
             const std::vector<std::shared_ptr<Variable2>>
             VariableController2::variables(const std::vector<QUuid>& ids)
             {
               std::vector<std::shared_ptr<Variable2>> variables;
               std::transform(std::cbegin(ids), std::cend(ids),
                              std::back_inserter(variables),
                              [this](const auto& id) { return impl->variable(id); });
               return variables;
             }

src/Variable/VariableModel2.cpp +5 -4

             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
-            #include <Common/StringUtils.h>
+            #include <cpp_utils_qt/cpp_utils_qt.hpp>
-            #include <Common/containers.h>
+            #include <strings/algorithms.hpp>
+            #include <containers/algorithms.hpp>
             #include <DataSource/DataSourceController.h>
             #include <QMimeData>
             #include <QSize>
             #include <QTimer>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableModel2.h>
             #include <unordered_map>
             namespace
             {
               // Column indexes
               const auto NAME_COLUMN     = 0;
               const auto TSTART_COLUMN   = 1;
               const auto TEND_COLUMN     = 2;
               const auto NBPOINTS_COLUMN = 3;
               const auto UNIT_COLUMN     = 4;
               const auto MISSION_COLUMN  = 5;
               const auto PLUGIN_COLUMN   = 6;
               const auto NB_COLUMNS      = 7;
               // 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}},
                   {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                   {UNIT_COLUMN, {QObject::tr("Unit")}},
                   {MISSION_COLUMN, {QObject::tr("Mission")}},
                   {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
               QString uniqueName(const QString& defaultName,
                                  const std::vector<std::shared_ptr<Variable2>>& 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);
+                auto uniqueName = cpp_utils::strings::make_unique_name(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
               }
             } // namespace
             VariableModel2::VariableModel2(QObject* parent) : QAbstractTableModel{parent} {}
             int VariableModel2::columnCount(const QModelIndex& parent) const
             {
               Q_UNUSED(parent);
               return NB_COLUMNS;
             }
             int VariableModel2::rowCount(const QModelIndex& parent) const
             {
               Q_UNUSED(parent);
               return _variables.size();
             }
             QVariant VariableModel2::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 = _variables[index.row()])
                 {
                   switch(index.column())
                   {
                     case NAME_COLUMN: return variable->name();
                     case TSTART_COLUMN:
                     {
                       if(auto range = variable->realRange(); range.has_value())
                         return DateUtils::dateTime(range.value().m_TStart)
                             .toString(DATETIME_FORMAT);
                       return QVariant{};
                     }
                     case TEND_COLUMN:
                     {
                       if(auto range = variable->realRange(); range.has_value())
                         return DateUtils::dateTime(range.value().m_TEnd)
                             .toString(DATETIME_FORMAT);
                       return QVariant{};
                     }
                     case NBPOINTS_COLUMN: return int(variable->nbPoints());
                     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;
                   }
                 }
               }
               else if(role == VariableRoles::ProgressRole)
               {
                 return QVariant{};
               }
               return QVariant{};
             }
             QVariant VariableModel2::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}};
                 }
               }
               return QVariant{};
             }
             Qt::ItemFlags VariableModel2::flags(const QModelIndex& index) const
             {
               return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled |
                      Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel2::supportedDropActions() const
             {
               return Qt::CopyAction | Qt::MoveAction;
             }
             Qt::DropActions VariableModel2::supportedDragActions() const
             {
               return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel2::mimeTypes() const
             {
               return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData* VariableModel2::mimeData(const QModelIndexList& indexes) const
             {
               auto mimeData = new QMimeData;
               std::vector<std::shared_ptr<Variable2>> variables;
               DateTimeRange firstTimeRange;
               for(const auto& index : indexes)
               {
                 if(index.column() == 0)
                 { // only the first column
                   auto variable = _variables[index.row()];
                   if(variable.get() && index.isValid())
                   {
                     if(variables.size() == 0)
                     {
                       // Gets the range of the first variable
                       firstTimeRange = variable->range();
                     }
                     variables.push_back(variable);
                   }
                 }
               }
               auto variablesEncodedData = Variable2::mimeData(variables);
               mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
               if(variables.size() == 1)
               {
                 // No time range MIME data if multiple variables are dragged
                 auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
               }
               return mimeData;
             }
             bool VariableModel2::canDropMimeData(const QMimeData* data,
                                                  Qt::DropAction action, int row, int column,
                                                  const QModelIndex& parent) const
             {
               Q_UNUSED(column);
               // drop of a product
               return data->hasFormat(MIME_TYPE_PRODUCT_LIST) ||
                      (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid() &&
                       !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel2::dropMimeData(const QMimeData* data, Qt::DropAction action,
                                               int row, int column,
                                               const QModelIndex& parent)
             {
               auto dropDone = false;
               if(data->hasFormat(MIME_TYPE_PRODUCT_LIST))
               {
                 auto productList = DataSourceController::productsDataForMimeData(
                     data->data(MIME_TYPE_PRODUCT_LIST));
                 for(auto metaData : productList)
                 {
                   emit createVariable(metaData.toHash());
                 }
                 dropDone = true;
               }
               else if(data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid())
               {
                 auto variable = _variables[parent.row()];
                 auto range =
                     TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
                 emit asyncChangeRange(variable, range);
                 dropDone = true;
               }
               return dropDone;
             }
             void VariableModel2::variableUpdated(QUuid id) noexcept
             {
               emit dataChanged(QModelIndex(), QModelIndex());
             }
             void VariableModel2::variableAdded(const std::shared_ptr<Variable2>& variable)
             {
-              if(!SciQLop::containers::contains(_variables, variable))
+              if(!cpp_utils::containers::contains(_variables, variable))
               {
                 beginInsertRows(QModelIndex(), this->_variables.size(),
                                 this->_variables.size());
                 this->_variables.push_back(variable);
                 endInsertRows();
                 connect(variable.get(), &Variable2::updated, this,
                         &VariableModel2::variableUpdated);
               }
             }
             void VariableModel2::variableDeleted(const std::shared_ptr<Variable2>& variable)
             {
               auto it = std::find(_variables.begin(), _variables.end(), variable);
               if(it != _variables.end())
               {
                 auto index = std::distance(_variables.begin(), it);
                 beginRemoveRows(QModelIndex(), index, index);
                 _variables.erase(it);
                 endRemoveRows();
               }
             }

tests/Data/TestDateTimeRange.cpp +1 -1

-            #include <Common/Numeric.h>
+            #include <Numeric.h>
             #include <Data/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <QObject>
             #include <QUuid>
             #include <QtTest>
             #include <limits>
             Q_DECLARE_METATYPE(Seconds<double>);
             Q_DECLARE_METATYPE(DateTimeRangeTransformation);
             DateTimeRange computeZoom(QDateTime start, QDateTime stop, double zoom)
             {
               double start_epoch = start.toMSecsSinceEpoch();
               double stop_epoch  = stop.toMSecsSinceEpoch();
               auto delta         = stop_epoch - start_epoch;
               auto dt_ms         = (zoom - 1.) * (double(delta)) / 2.;
               return DateTimeRange{(start_epoch - dt_ms) / 1000.,
                                    (stop_epoch + dt_ms) / 1000.};
             }
             class TestDateTimeRange : public QObject
             {
               Q_OBJECT
             private slots:
               void testRangeDelta_data()
               {
                 QTest::addColumn<QDateTime>("tstart");
                 QTest::addColumn<QDateTime>("tend");
                 QTest::addColumn<double>("expected");
                 auto now       = QDateTime::currentDateTime();
                 auto yesterday = QDateTime::currentDateTime().addDays(-1);
                 QTest::newRow("No delta") << now << now << 0.;
                 QTest::newRow("One day delta") << yesterday << now << 60. * 60. * 24.;
                 QTest::newRow("Minus one day delta")
                     << now << yesterday << -60. * 60. * 24.;
               }
               void testRangeDelta()
               {
                 QFETCH(QDateTime, tstart);
                 QFETCH(QDateTime, tend);
                 QFETCH(double, expected);
                 auto range   = DateTimeRange::fromDateTime(tstart, tend);
                 double delta = range.delta();
                 // Since it is built from QDateTime don't expect better resolution
                 QVERIFY((delta - expected) <= 0.002);
               }
               void testRangeShift_data()
               {
                 QTest::addColumn<DateTimeRange>("initial");
                 QTest::addColumn<Seconds<double>>("shift");
                 QTest::addColumn<DateTimeRange>("expected");
                 auto now   = QDateTime::currentDateTime();
                 auto yestd = QDateTime::currentDateTime().addDays(-1);
                 auto range = DateTimeRange::fromDateTime(yestd, now);
                 QTest::newRow("No shift") << range << Seconds<double>{0.} << range;
                 QTest::newRow("One milisecond left")
                     << range << Seconds<double>{-.001}
                     << DateTimeRange::fromDateTime(yestd.addMSecs(-1.), now.addMSecs(-1.));
                 QTest::newRow("One milisecond right")
                     << range << Seconds<double>{.001}
                     << DateTimeRange::fromDateTime(yestd.addMSecs(1.), now.addMSecs(1.));
                 QTest::newRow("One second left")
                     << range << Seconds<double>{-1.}
                     << DateTimeRange::fromDateTime(yestd.addSecs(-1.), now.addSecs(-1.));
                 QTest::newRow("One second right")
                     << range << Seconds<double>{1.}
                     << DateTimeRange::fromDateTime(yestd.addSecs(1.), now.addSecs(1.));
                 QTest::newRow("One year left")
                     << range << Seconds<double>{-365. * 24. * 60. * 60.}
                     << DateTimeRange::fromDateTime(yestd.addSecs(-365 * 24 * 60 * 60),
                                                    now.addSecs(-365 * 24 * 60 * 60));
                 QTest::newRow("One year right")
                     << range << Seconds<double>{365. * 24. * 60. * 60.}
                     << DateTimeRange::fromDateTime(yestd.addSecs(365 * 24 * 60 * 60),
                                                    now.addSecs(365 * 24 * 60 * 60));
               }
               void testRangeShift()
               {
                 QFETCH(DateTimeRange, initial);
                 QFETCH(Seconds<double>, shift);
                 QFETCH(DateTimeRange, expected);
                 QCOMPARE(initial + shift, expected);
               }
               void testRangeZoom_data()
               {
                 QTest::addColumn<DateTimeRange>("initial");
                 QTest::addColumn<double>("zoom");
                 QTest::addColumn<DateTimeRange>("expected");
                 auto now   = QDateTime::currentDateTime();
                 auto yestd = QDateTime::currentDateTime().addDays(-1);
                 auto range = DateTimeRange::fromDateTime(yestd, now);
                 QTest::newRow("No zoom") << range << 1. << range;
                 QTest::newRow("Zoom IN 0.001")
                     << range << 1.001 << computeZoom(yestd, now, 1.001);
                 QTest::newRow("Zoom OUT 0.001")
                     << range << 0.999 << computeZoom(yestd, now, 0.999);
               }
               void testRangeZoom()
               {
                 QFETCH(DateTimeRange, initial);
                 QFETCH(double, zoom);
                 QFETCH(DateTimeRange, expected);
                 QCOMPARE(initial * zoom, expected);
               }
               void testRangeContains_data()
               {
                 QTest::addColumn<DateTimeRange>("range");
                 QTest::addColumn<DateTimeRange>("range2");
                 QTest::addColumn<bool>("contains");
                 auto now   = QDateTime::currentDateTime();
                 auto yestd = QDateTime::currentDateTime().addDays(-1);
                 auto range = DateTimeRange::fromDateTime(yestd, now);
                 QTest::newRow("Same range") << range << range << true;
                 QTest::newRow("Smaller range") << range << range * 0.8 << true;
                 QTest::newRow("Bigger range") << range << range * 1.2 << false;
                 QTest::newRow("Shifted range with overlap")
                     << range << range + Seconds<double>{1000.} << false;
                 QTest::newRow("Shifted range without overlap")
                     << range << range + Seconds<double>{24. * 60. * 60. * 10} << false;
               }
               void testRangeContains()
               {
                 QFETCH(DateTimeRange, range);
                 QFETCH(DateTimeRange, range2);
                 QFETCH(bool, contains);
                 QCOMPARE(range.contains(range2), contains);
               }
               void testRangeIntersect_data()
               {
                 QTest::addColumn<DateTimeRange>("range");
                 QTest::addColumn<DateTimeRange>("range2");
                 QTest::addColumn<bool>("contains");
                 auto now      = QDateTime::currentDateTime();
                 auto yestd    = QDateTime::currentDateTime().addDays(-1);
                 auto tomorrow = QDateTime::currentDateTime().addDays(1);
                 auto range    = DateTimeRange::fromDateTime(yestd, now);
                 auto range2   = DateTimeRange::fromDateTime(now, tomorrow);
                 QTest::newRow("Same range") << range << range << true;
                 QTest::newRow("Smaller range") << range << range * 0.8 << true;
                 QTest::newRow("Bigger range") << range << range * 1.2 << true;
                 QTest::newRow("Shifted range with overlap")
                     << range << range + Seconds<double>{1000.} << true;
                 QTest::newRow("Shifted range with overlaping boundary")
                     << range << range2 << true;
                 QTest::newRow("Shifted range .1 seonds outside")
                     << range << range2 + Seconds<double>{.1} << false;
                 QTest::newRow("Shifted range without overlap")
                     << range << range + Seconds<double>{24. * 60. * 60. * 10} << false;
               }
               void testRangeIntersect()
               {
                 QFETCH(DateTimeRange, range);
                 QFETCH(DateTimeRange, range2);
                 QFETCH(bool, contains);
                 QCOMPARE(range.intersect(range2), contains);
               }
               void testRangeTransformations_data()
               {
                 QTest::addColumn<DateTimeRange>("range1");
                 QTest::addColumn<DateTimeRange>("range2");
                 QTest::addColumn<DateTimeRangeTransformation>("transformation");
                 auto now   = QDateTime::currentDateTime();
                 auto yestd = QDateTime::currentDateTime().addDays(-1);
                 auto range = DateTimeRange::fromDateTime(yestd, now);
                 QTest::newRow("Same range")
                     << range << range
                     << DateTimeRangeTransformation{1., Seconds<double>{0.}};
                 QTest::newRow("Transformatio 1.1x + 10s")
                     << range << range * 1.1 + Seconds<double>{10.}
                     << DateTimeRangeTransformation{1.1, Seconds<double>{10.}};
                 QTest::newRow("Transformatio 1.x + 10s")
                     << range << range * 1. + Seconds<double>{10.}
                     << DateTimeRangeTransformation{1., Seconds<double>{10.}};
                 QTest::newRow("Transformatio 1.1x + 0s")
                     << range << range * 1.1 + Seconds<double>{0.}
                     << DateTimeRangeTransformation{1.1, Seconds<double>{0.}};
                 QTest::newRow("Transformatio 0.9x - 10s")
                     << range << range * 0.9 + Seconds<double>{-10.}
                     << DateTimeRangeTransformation{0.9, Seconds<double>{-10.}};
               }
               void testRangeTransformations()
               {
                 QFETCH(DateTimeRange, range1);
                 QFETCH(DateTimeRange, range2);
                 QFETCH(DateTimeRangeTransformation, transformation);
                 auto computed_tr =
                     DateTimeRangeHelper::computeTransformation(range1, range2).value();
                 QCOMPARE(computed_tr, transformation);
                 QCOMPARE(range1.transform(transformation), range2);
                 QCOMPARE(range1.transform(computed_tr), range2);
               }
               void testRangeDiff_data()
               {
                 QTest::addColumn<DateTimeRange>("source");
                 QTest::addColumn<DateTimeRange>("destination");
                 QTest::addColumn<int>("count");
                 auto now   = QDateTime::currentDateTime();
                 auto yestd = QDateTime::currentDateTime().addDays(-1);
                 auto range = DateTimeRange::fromDateTime(yestd, now);
                 QTest::newRow("Same range") << range << range << 0;
                 QTest::newRow("No missing data (zoom in)") << range << range * 0.9 << 0;
                 QTest::newRow("Missing data on both sides (zoom out)")
                     << range << range * 2. << 2;
                 QTest::newRow("Missing data on left side (pan left)")
                     << range << range - Seconds<double>{1000.} << 1;
                 QTest::newRow("Missing data on right side (pan right)")
                     << range << range + Seconds<double>{1000.} << 1;
                 QTest::newRow("Missing data on right side no intersect (big pan right)")
                     << range << range + Seconds<double>{24. * 60. * 60. * 2} << 1;
                 QTest::newRow("Missing data on left side no intersect (big pan left)")
                     << range << range - Seconds<double>{24. * 60. * 60. * 2} << 1;
               }
               void testRangeDiff()
               {
                 QFETCH(DateTimeRange, source);
                 QFETCH(DateTimeRange, destination);
                 QFETCH(int, count);
                 auto diff = destination - source;
                 QCOMPARE(diff.size(), count);
                 for(const auto& range : diff)
                 {
                   QVERIFY(range.delta().value > 0.);
                 }
               }
             };
             QTEST_MAIN(TestDateTimeRange)
             #include "TestDateTimeRange.moc"

tests/Variable/TestVariableController2.cpp +4 -4

-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
             #include <QObject>
             #include <QtTest>
             #include <TestUtils/TestProviders.h>
             #include <Variable/VariableController2.h>
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #define TEST_VC2_FIXTURE(slope)                                                \
               VariableController2 vc;                                                      \
               auto provider = std::make_shared<SimpleRange<slope>>();
             #define TEST_VC2_CREATE_DEFAULT_VAR(name)                                      \
               auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),   \
                                                        QDate(2018, 8, 7), QTime(16, 00));  \
               auto name  = vc.createVariable("name", {}, provider, range);                 \
               while(!vc.isReady(name))                                                     \
                 QCoreApplication::processEvents();
             Q_DECLARE_METATYPE(DateTimeRangeTransformation);
             class TestVariableController2 : public QObject
             {
               Q_OBJECT
             public:
               explicit TestVariableController2(QObject* parent = nullptr) : QObject(parent)
               {}
             signals:
             private slots:
               void initTestCase() {}
               void cleanupTestCase() {}
               void testCreateVariable()
               {
                 TEST_VC2_FIXTURE(2);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableAdded,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 QVERIFY(!callbackCalled);
                 auto var1 = vc.createVariable("var1", {}, provider, range);
-                QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testDeleteVariable()
               {
                 TEST_VC2_FIXTURE(1);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableDeleted,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 auto var1 = vc.createVariable("var1", {}, provider, range);
                 while(!vc.isReady(var1))
                   QCoreApplication::processEvents();
-                QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(!callbackCalled);
                 vc.deleteVariable(var1);
-                QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(!cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testGetData()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
               }
               void testZoom_data()
               {
                 QTest::addColumn<double>("zoom");
                 QTest::newRow("Zoom IN 10x") << .1;
                 QTest::newRow("Zoom OUT 10x") << 10.;
                 QTest::newRow("Zoom IN 1x") << 1.;
               }
               void testZoom()
               {
                 TEST_VC2_FIXTURE(100);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<100>>(var1, range);
                 QFETCH(double, zoom);
                 range *= zoom;
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<100>>(var1, range);
               }
               void testPan_data()
               {
                 QTest::addColumn<double>("pan");
                 QTest::newRow("Right 1000 seconds") << 1000.;
                 QTest::newRow("Left 1000 seconds") << -1000.;
                 QTest::newRow("Right 0.1 seconds") << .1;
                 QTest::newRow("Left 0.1 seconds") << -.1;
               }
               void testPan()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
                 QFETCH(double, pan);
                 range += Seconds<double>{pan};
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<10>>(var1, range);
               }
               void testCache_data()
               {
                 QTest::addColumn<DateTimeRangeTransformation>("transformation");
                 QTest::addColumn<int>("expectedIncrement");
                 QTest::newRow("zoom in")
                     << DateTimeRangeTransformation{0.8, Seconds<double>(0.)} << 0;
                 QTest::newRow("tiny zoom out")
                     << DateTimeRangeTransformation{1.01, Seconds<double>(0.)} << 0;
                 QTest::newRow("just under cache zoom out")
                     << DateTimeRangeTransformation{2.0 / 1.1, Seconds<double>(0.)} << 0;
                 QTest::newRow("just over cache zoom out")
                     << DateTimeRangeTransformation{2.001 / 1.1, Seconds<double>(0.)} << 2;
                 QTest::newRow("tiny pan left")
                     << DateTimeRangeTransformation{1., Seconds<double>(-100.)} << 0;
                 QTest::newRow("tiny pan right")
                     << DateTimeRangeTransformation{1., Seconds<double>(100.)} << 0;
               }
               void testCache()
               {
                 QSKIP("The cache is disabled for now");
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
                 QFETCH(DateTimeRangeTransformation, transformation);
                 QFETCH(int, expectedIncrement);
                 auto initialCount = provider->callCounter;
                 range             = range.transform(transformation);
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<10>>(var1, range);
                 QCOMPARE(provider->callCounter - initialCount, expectedIncrement);
               }
             };
             QTEST_MAIN(TestVariableController2)
             #include "TestVariableController2.moc"

tests/Variable/TestVariableController2Async.cpp +1 -1

-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
             #include <Data/ScalarTimeSerie.h>
             #include <QObject>
             #include <QtTest>
             #include <TestUtils/TestProviders.h>
             #include <Variable/VariableController2.h>
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #define TEST_VC2_FIXTURE(slope)                                                \
               VariableController2 vc;                                                      \
               auto provider = std::make_shared<SimpleRange<slope>>();
             #define TEST_VC2_CREATE_DEFAULT_VARS(name1, name2, name3)                      \
               auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),   \
                                                        QDate(2018, 8, 7), QTime(16, 00));  \
               auto name1 = vc.createVariable("name1", {}, provider, range);                \
               auto name2 = vc.createVariable("name1", {}, provider, range);                \
               auto name3 = vc.createVariable("name1", {}, provider, range);                \
               vc.synchronize(name1, name2);
             class TestVariableController2Async : public QObject
             {
               Q_OBJECT
             public:
               explicit TestVariableController2Async(QObject* parent = nullptr)
                   : QObject(parent)
               {}
             signals:
             private slots:
               void initTestCase() {}
               void cleanupTestCase() {}
               void testSimplePan()
               {
                 TEST_VC2_FIXTURE(2);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 int variableUpdated = 0;
                 auto var1           = vc.createVariable("var1", {}, provider, range);
                 auto var2           = vc.createVariable("var2", {}, provider, range);
                 auto var3           = vc.createVariable("var3", {}, provider, range);
                 connect(&(*var2), &Variable2::updated,
                         [&variableUpdated]() { variableUpdated += 1; });
                 vc.synchronize(var1, var2);
                 vc.asyncChangeRange(var1, range + Seconds<double>{10000.});
                 vc.asyncChangeRange(var1, range + Seconds<double>{50000.});
                 vc.asyncChangeRange(var1, range + Seconds<double>{100000.});
                 vc.asyncChangeRange(var1, range + Seconds<double>{150000.});
                 while(!vc.isReady(var1) || !vc.isReady(var2))
                 {
                   QCoreApplication::processEvents();
                 }
               }
             };
             QTEST_MAIN(TestVariableController2Async)
             #include "TestVariableController2Async.moc"

tests/Variable/TestVariableController2WithSync.cpp +4 -4

-            #include <Common/containers.h>
+            #include <containers/algorithms.hpp>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
             #include <Data/ScalarTimeSerie.h>
             #include <QObject>
             #include <QtTest>
             #include <TestUtils/TestProviders.h>
             #include <Variable/VariableController2.h>
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #define TEST_VC2_FIXTURE(slope)                                                \
               VariableController2 vc;                                                      \
               auto provider = std::make_shared<SimpleRange<slope>>();
             #define TEST_VC2_CREATE_DEFAULT_VARS(name1, name2, name3)                      \
               auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),   \
                                                        QDate(2018, 8, 7), QTime(16, 00));  \
               auto name1 = vc.createVariable("name1", {}, provider, range);                \
               while(!vc.isReady(name1))                                                    \
                 QCoreApplication::processEvents();                                         \
               auto name2 = vc.cloneVariable(name1);                                        \
               auto name3 = vc.cloneVariable(name2);                                        \
               vc.synchronize(name1, name2);                                                \
               while(!vc.isReady(name1))                                                    \
                 QCoreApplication::processEvents();
             class TestVariableController2WithSync : public QObject
             {
               Q_OBJECT
             public:
               explicit TestVariableController2WithSync(QObject* parent = nullptr)
                   : QObject(parent)
               {}
             signals:
             private slots:
               void initTestCase() {}
               void cleanupTestCase() {}
               void testCreateVariable()
               {
                 TEST_VC2_FIXTURE(2);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableAdded,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 QVERIFY(!callbackCalled);
                 auto var1 = vc.createVariable("var1", {}, provider, range);
-                QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testDeleteVariable()
               {
                 TEST_VC2_FIXTURE(1);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableDeleted,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 auto var1 = vc.createVariable("var1", {}, provider, range);
-                QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(!callbackCalled);
                 while(!vc.isReady(var1))
                 {
                   qApp->processEvents();
                 }
                 vc.deleteVariable(var1);
-                QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
+                QVERIFY(!cpp_utils::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testGetData()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VARS(var1, var2, var3);
                 check_variable_state<RangeType<10>>(var1, range);
                 auto newRange = var2->range() * 1.5 + Seconds<double>{1000.};
                 vc.changeRange(var2, newRange);
                 check_variable_state<RangeType<10>>(var1, newRange);
                 check_variable_state<RangeType<10>>(var2, newRange);
                 check_variable_state<RangeType<10>>(var3, range);
               }
               void testZoom_data()
               {
                 QTest::addColumn<double>("zoom");
                 QTest::newRow("Zoom IN 10x") << .1;
                 QTest::newRow("Zoom OUT 10x") << 10.;
                 QTest::newRow("Zoom IN 1x") << 1.;
               }
               void testZoom()
               {
                 TEST_VC2_FIXTURE(100);
                 TEST_VC2_CREATE_DEFAULT_VARS(var1, var2, var3);
                 check_variable_state<RangeType<100>>(var1, range);
                 QFETCH(double, zoom);
                 range *= zoom;
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<100>>(var1, range);
                 check_variable_state<RangeType<100>>(var2, range);
               }
               void testPan_data()
               {
                 QTest::addColumn<double>("pan");
                 QTest::newRow("Right 1000 seconds") << 1000.;
                 QTest::newRow("Left 1000 seconds") << -1000.;
                 QTest::newRow("Right 0.1 seconds") << .1;
                 QTest::newRow("Left 0.1 seconds") << -.1;
               }
               void testPan()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VARS(var1, var2, var3);
                 check_variable_state<RangeType<10>>(var1, range);
                 QFETCH(double, pan);
                 range += Seconds<double>{pan};
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<10>>(var1, range);
                 check_variable_state<RangeType<10>>(var2, range);
               }
             };
             QTEST_MAIN(TestVariableController2WithSync)
             #include "TestVariableController2WithSync.moc"

tests/meson.build 0 -10

             TestUtils = library('TestUtils', 'TestUtils/TestProviders.h', 'TestUtils/TestProviders.cpp',
                                    dependencies : [sciqlop_core, qt5test]
                                    )
             TestUtils_dep = declare_dependency(link_with : TestUtils,
                                             dependencies : [sciqlop_core, qt5test])
             tests = [
                 {
-                    'name':'TestStringUtils',
-                    'sources': ['Common/TestStringUtils.cpp'],
-                    'deps': [sciqlop_core, qt5test]
-                },
-                    'name':'TestContainers',
-                    'sources': ['Common/TestContainers.cpp'],
-                    'deps': [sciqlop_core, qt5test]
-                },
                     'name':'TestSyncGroup',
                     'sources': ['Variable/TestSyncGroup.cpp'],
                     'deps': [sciqlop_core, qt5test]
                 },
                 {
                     'name':'TestDateTimeRange',
                     'sources': ['Data/TestDateTimeRange.cpp'],
                     'deps': [sciqlop_core, qt5test]
                 },
                 {
                     'name':'TestDataSourceController',
                     'sources': [
                                 'DataSource/TestDataSourceController.cpp',
                                 'DataSource/DataSourceItemBuilder.cpp'
                                ],
                     'deps': [sciqlop_core, qt5test]
                 },
                 {
                     'name':'TestDataSourceItem',
                     'sources': [
                                 'DataSource/TestDataSourceItem.cpp',
                                 'DataSource/DataSourceItemBuilder.cpp'
                                ],
                     'deps': [sciqlop_core, qt5test]
                 },
                 {
                     'name':'TestVariable',
                     'sources': ['Variable/TestVariable.cpp'],
                     'deps': [sciqlop_core, qt5test]
                 },
                 {
                     'name':'TestDownloader',
                     'sources': ['Network/TestDownloader.cpp'],
                     'deps': [sciqlop_core, qt5test, qt5Concurrent]
                 },
                 {
                     'name':'TestVariableController2',
                     'sources': ['Variable/TestVariableController2.cpp'],
                     'deps': [sciqlop_core, qt5test, qt5Concurrent, TestUtils_dep]
                 },
                 {
                     'name':'TestVariableController2Async',
                     'sources': ['Variable/TestVariableController2Async.cpp'],
                     'deps': [sciqlop_core, qt5test, qt5Concurrent, TestUtils_dep]
                 },
                 {
                     'name':'TestVariableController2WithSync',
                     'sources': ['Variable/TestVariableController2WithSync.cpp'],
                     'deps': [sciqlop_core, qt5test, qt5Concurrent, TestUtils_dep]
                 }
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test['sources'])
               test_exe = executable(unit_test['name'],unit_test['sources'] , test_moc_files,
                                       dependencies : unit_test['deps'],
             						  cpp_args : ['-DCORE_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/../tests-resources"']
             						  )
               test('Test-' + unit_test['name'], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test['name'])])
             endforeach

include/Common/Numeric.h removed 0 -26

NO CONTENT: file was removed

include/Common/StringUtils.h removed 0 -90

NO CONTENT: file was removed

include/Common/containers.h removed 0 -49

NO CONTENT: file was removed

include/Common/cpp_utils.h removed 0 -66

NO CONTENT: file was removed

include/Common/deprecate.h removed 0 -10

NO CONTENT: file was removed

include/Common/trees.h removed 0 -57

NO CONTENT: file was removed

include/Common/types_detectors.h removed 0 -40

NO CONTENT: file was removed

src/Common/StringUtils.cpp removed 0 -5

NO CONTENT: file was removed

tests/Common/TestContainers.cpp removed 0 -36

NO CONTENT: file was removed

tests/Common/TestStringUtils.cpp removed 0 -50

NO CONTENT: file was removed

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