Switch to std::ranges (#350)

* Remove "using namespace std" and make std namespace explicit

* Remove "using namespace std" and make std namespace explicit

* Add ranges library and use it

CMakeLists.txt

@@ -12,6 +12,11 @@ project (TermGraph
 
 set (CMAKE_CXX_SCAN_FOR_MODULES False)
 
+# Enable ranges support for emscripten
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_compile_options(-fexperimental-library)
+endif()
+
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten")
     set (WASM "True")
 endif ()

lib/Graph/include/Graph/Forest.hpp

@@ -7,9 +7,12 @@
 #include <deque>
 #include <functional>
 #include <map>
+#include <ranges>
 
 #include <Graph/Graph.hpp>
 
+namespace rng = std::ranges;
+
 namespace graph {
 
 enum class NodeType { Orphan, Root, EndLeaf, MiddleLeaf };
@@ -222,7 +225,7 @@ class Forest : public Graph<NodeT, EdgeT>
         for (const auto& node : BaseData::nodes) {
             auto edges = tooShortEdges(node);
 
-            std::for_each(edges.begin(), edges.end(), [&wEdges](auto edge) {
+            rng::for_each(edges, [&wEdges](auto edge) {
                 if (!wEdges.contains(edge))
                     wEdges.insert(edge);
             });
@@ -250,24 +253,22 @@ class Forest : public Graph<NodeT, EdgeT>
 
     std::map<NodePtr, int> getLevels() const
     {
-        using namespace std;
-
-        map<NodePtr, int> ret;
-        deque<NodePtr>    visitQueue;
-        auto              rootNodes = roots();
+        std::map<NodePtr, int> ret;
+        std::deque<NodePtr>    visitQueue;
+        auto                   rootNodes = roots();
 
-        for_each(BaseData::nodes.begin(), BaseData::nodes.end(), [&ret](auto node) { ret[node] = 0; });
-        for_each(rootNodes.begin(), rootNodes.end(), [&visitQueue](auto node) { visitQueue.push_back(node); });
+        rng::for_each(BaseData::nodes, [&ret](auto node) { ret[node] = 0; });
+        rng::for_each(rootNodes, [&visitQueue](auto node) { visitQueue.push_back(node); });
 
         while (!visitQueue.empty()) // Just steps limit
         {
             auto node = visitQueue.front();
             visitQueue.pop_front();
 
             for (const auto& leaf : leafNodes(node)) {
-                ret[leaf] = max(ret[node] + 1, ret[leaf]);
+                ret[leaf] = std::max(ret[node] + 1, ret[leaf]);
 
-                if (find(visitQueue.begin(), visitQueue.end(), leaf) == visitQueue.end()) // Not found
+                if (rng::find(visitQueue, leaf) == visitQueue.end()) // Not found
                     visitQueue.push_back(leaf);
             }
         }
@@ -296,7 +297,7 @@ class Forest : public Graph<NodeT, EdgeT>
         nodeStates[node] = NodeState::AtPath;
 
         for (auto edge : mEdgesToLeafs.at(node)) {
-            auto iter = std::find(breakEdges.begin(), breakEdges.end(), edge);
+            auto iter = rng::find(breakEdges, edge);
             if (iter != breakEdges.end())
                 continue;
 
@@ -319,8 +320,6 @@ class Forest : public Graph<NodeT, EdgeT>
                              const std::map<NodePtr, EdgeList>&              edgesList,
                              bool                                            checkCondition = true)
     {
-        using namespace std;
-
         if (visitQueue.empty())
             return;
 
@@ -336,7 +335,7 @@ class Forest : public Graph<NodeT, EdgeT>
         for (const auto& edge : edgesList.at(node)) {
             auto rootNode = edge->oppositeTo(node);
 
-            bool found = find(visitQueue.begin(), visitQueue.end(), rootNode) != visitQueue.end();
+            bool found = rng::find(visitQueue, rootNode) != visitQueue.end();
 
             if (!found)
                 visitQueue.push_back(rootNode);

lib/Graph/include/Graph/Graph.hpp

@@ -40,8 +40,8 @@ class Graph : protected GraphData<NodeT, EdgeT>
         std::set<NodePtr> nodeSet(data.nodes.begin(), data.nodes.end());
         std::set<EdgePtr> edgeSet(data.edges.begin(), data.edges.end());
 
-        assert(rng::size(nodeSet) == rng::size(data.nodes));
-        assert(rng::size(edgeSet) == rng::size(data.edges));
+        assert(nodeSet.size() == data.nodes.size());
+        assert(edgeSet.size() == data.edges.size());
     }
 
     const NodeList& nodeList() const { return Base::nodes; }
@@ -55,9 +55,7 @@ class Graph : protected GraphData<NodeT, EdgeT>
         auto ret = Base::nodes;
 
         auto removeIt = std::remove_if(ret.begin(), ret.end(), [this](auto node) {
-            auto it = std::find_if(Base::edges.begin(), Base::edges.end(), [&node](auto edge) {
-                return edge->incidentalTo(node);
-            });
+            auto it = rng::find_if(Base::edges, [&node](auto edge) { return edge->incidentalTo(node); });
 
             return it != Base::edges.end();
         });
@@ -73,9 +71,7 @@ class Graph : protected GraphData<NodeT, EdgeT>
         auto ret      = Base::nodes;
 
         auto removeIt = std::remove_if(ret.begin(), ret.end(), [&isolated](auto node) {
-            auto it = std::find(isolated.begin(), isolated.end(), node);
-
-            return it != isolated.end();
+            return rng::find(isolated, node) != isolated.end();
         });
 
         ret.erase(removeIt, ret.end());
@@ -109,10 +105,8 @@ class Graph : protected GraphData<NodeT, EdgeT>
 
     typename GraphData<NodeT, EdgeT>::List bondedSubgraphs()
     {
-        using namespace std;
-
         enum class State { NotVisited = 0, Planned, Visited };
-        map<NodePtr, State> nodesVisitList;
+        std::map<NodePtr, State> nodesVisitList;
 
         for (const auto& node : connectedNodes())
             nodesVisitList[node] = State::NotVisited;
@@ -125,12 +119,12 @@ class Graph : protected GraphData<NodeT, EdgeT>
         auto isNodePlanned = [](const auto& val) { return val.second == State::Planned; };
         auto isNodeVisited = [](const auto& val) { return val.second == State::Visited; };
 
-        set<NodePtr> uniqueNodes;
-        set<EdgePtr> uniqueEdges;
+        std::set<NodePtr> uniqueNodes;
+        std::set<EdgePtr> uniqueEdges;
 
         while (!nodesVisitList.empty()) {
             // Visit stage
-            auto nodeToVisit = find_if(nodesVisitList.begin(), nodesVisitList.end(), isNodePlanned);
+            auto nodeToVisit = std::find_if(nodesVisitList.begin(), nodesVisitList.end(), isNodePlanned);
 
             // If no any nodes in plan, take first
             if (nodeToVisit == nodesVisitList.end())
@@ -148,13 +142,11 @@ class Graph : protected GraphData<NodeT, EdgeT>
                     nodesVisitList[neighbourNode] = State::Planned;
             }
 
-            for_each(neighbours.edges.begin(), neighbours.edges.end(), [&uniqueEdges](auto edge) {
-                uniqueEdges.insert(edge);
-            });
+            rng::for_each(neighbours.edges, [&uniqueEdges](auto edge) { uniqueEdges.insert(edge); });
 
             // Cut stage
-            auto plannedCount = count_if(nodesVisitList.begin(), nodesVisitList.end(), isNodePlanned);
-            auto visitedCount = count_if(nodesVisitList.begin(), nodesVisitList.end(), isNodeVisited);
+            auto plannedCount = rng::count_if(nodesVisitList, isNodePlanned);
+            auto visitedCount = rng::count_if(nodesVisitList, isNodeVisited);
 
             if (plannedCount == 0 && visitedCount > 0) {
                 // Nodes preparations
@@ -165,7 +157,7 @@ class Graph : protected GraphData<NodeT, EdgeT>
                 uniqueEdges.clear();
 
                 // Remove visited from nodesVisitList
-                erase_if(nodesVisitList, isNodeVisited);
+                std::erase_if(nodesVisitList, isNodeVisited);
             }
         }
 

lib/Graph/include/Graph/GraphData.hpp

@@ -4,11 +4,14 @@
 #pragma once
 
 #include <functional>
+#include <ranges>
 #include <vector>
 
 #include <Graph/Edge.hpp>
 #include <Graph/Node.hpp>
 
+namespace rng = std::ranges;
+
 namespace graph {
 
 template<typename NodeT, typename EdgeT>
@@ -26,8 +29,8 @@ struct GraphData
     NodeList nodes;
     EdgeList edges;
 
-    bool contains(const NodePtr& node) const { return std::find(nodes.begin(), nodes.end(), node) != nodes.end(); }
-    bool contains(const EdgePtr& edge) const { return std::find(edges.begin(), edges.end(), edge) != edges.end(); }
+    bool contains(const NodePtr& node) const { return rng::find(nodes, node) != nodes.end(); }
+    bool contains(const EdgePtr& edge) const { return rng::find(edges, edge) != edges.end(); }
 
     NodeList filterNodes(std::function<bool(const NodePtr&)> condition) const
     {
@@ -54,7 +57,7 @@ struct GraphData
         NodeList ret = baseList;
 
         auto remIt = std::remove_if(ret.begin(), ret.end(), [&subtractor](auto node) {
-            return std::find(subtractor.begin(), subtractor.end(), node) != subtractor.end();
+            return rng::find(subtractor, node) != subtractor.end();
         });
 
         ret.erase(remIt, ret.end());
@@ -67,7 +70,7 @@ struct GraphData
         EdgeList ret = baseList;
 
         auto remIt = std::remove_if(ret.begin(), ret.end(), [&subtractor](auto node) {
-            return std::find(subtractor.begin(), subtractor.end(), node) != subtractor.end();
+            return rng::find(subtractor, node) != subtractor.end();
         });
 
         ret.erase(remIt, ret.end());

lib/StaticDataStorage/source/StaticDataStorage.cpp

@@ -3,9 +3,13 @@
 
 #include "include/StaticDataStorage/StaticDataStorage.h"
 
+#include <ranges>
+
 #include <QDir>
 #include <QMap>
 
+namespace rng = std::ranges;
+
 StaticDataStorage::StaticDataStorage()
     : DataStorageInterface()
 {
@@ -70,8 +74,7 @@ FutureResult<GroupSummary::List> StaticDataStorage::groups() const
         auto groups = mGroups.values();
 
         // Sorting this structure
-        auto groupOrdering = [](const auto& g1, const auto& g2) { return g1.termsLastEdit() > g2.termsLastEdit(); };
-        std::sort(groups.begin(), groups.end(), groupOrdering);
+        rng::sort(groups, [](const auto& g1, const auto& g2) { return g1.termsLastEdit() > g2.termsLastEdit(); });
 
         GroupSummary::List result;
 

lib/TermDataStorage/source/LocalDataStorage.cpp

@@ -3,10 +3,14 @@
 
 #include "include/TermDataStorage/LocalDataStorage.h"
 
+#include <ranges>
+
 #include <QMap>
 
 #include "source/Database.h"
 
+namespace rng = std::ranges;
+
 class StorageImpl
 {
 public:
@@ -48,9 +52,7 @@ FutureResult<GroupSummary::List> LocalDatabaseStorage::groups() const
         }
 
         // Sorting this structure
-        auto groupOrdering = [](const auto& g1, const auto& g2) { return g1.nodesLastEdit > g2.nodesLastEdit; };
-
-        std::sort(groups.begin(), groups.end(), groupOrdering);
+        rng::sort(groups, [](const auto& g1, const auto& g2) { return g1.nodesLastEdit > g2.nodesLastEdit; });
 
         return groups;
     });

source/dataprovider.cpp

@@ -3,8 +3,12 @@
 
 #include "dataprovider.h"
 
+#include <ranges>
+
 #include "source/datasourcefactory.h"
 
+namespace rng = std::ranges;
+
 DataProvider::DataProvider(QObject *parent)
     : QObject{parent}
     , dataStorage{DataSourceFactory::defaultSource()}

source/mainscene.cpp

@@ -71,16 +71,14 @@ void MainScene::checkGroupAddition()
 
 void MainScene::checkGroupDeletion()
 {
-    using namespace std;
-
     // If group was deleted, and it was current group, we must delete it too
     auto currentGroup = currentGroupUuid();
     if (!currentGroup) {
         return;
     }
 
     auto groupsUuids = groupsMgr->getAllUuidsSortedByLastEdit();
-    if (find(begin(groupsUuids), end(groupsUuids), *currentGroup) == groupsUuids.end()) {
+    if (rng::find(groupsUuids, *currentGroup) == groupsUuids.end()) {
         dropGroup();
     }
 }

source/managers/linkshardeningmanager.cpp

@@ -3,11 +3,15 @@
 
 #include "source/managers/linkshardeningmanager.h"
 
+#include <ranges>
+
 #include <CommonTools/HandyTypes.h>
 
 #include "source/helpers/link/linksdecorator.h"
 #include "source/helpers/link/linktools.h"
 
+namespace rng = std::ranges;
+
 LinksHardeningManager::LinksHardeningManager(QObject *parent)
     : QAbstractListModel(parent)
 {
@@ -109,8 +113,7 @@ LinksHardeningManager::SearchResultList LinksHardeningManager::getNearestVariant
         distances.push_back(std::pair(distance, term.get()));
     }
 
-    auto sortCondition = [](auto pair1, auto pair2) { return pair1.first < pair2.first; };
-    std::sort(distances.begin(), distances.end(), sortCondition);
+    rng::sort(distances, [](auto pair1, auto pair2) { return pair1.first < pair2.first; });
 
     auto min = static_cast<decltype(distances)::size_type>(std::min(limit, asInt(distances.size())));
 

source/model/group/nodeverticalstack.cpp

@@ -3,6 +3,10 @@
 
 #include "source/model/group/nodeverticalstack.h"
 
+#include <ranges>
+
+namespace rng = std::ranges;
+
 QSizeF NodeVerticalStackTools::getNodeVerticalStackedSize(const PaintedTerm::List& nodes)
 {
     SizeList sizeList;
@@ -20,11 +24,7 @@ NodeVerticalStack::NodeVerticalStack(PaintedForest* parentForest)
 
 void NodeVerticalStack::addTerm(PaintedTerm::Ptr term) { mTerms.push_back(term); }
 
-bool NodeVerticalStack::hasNode(PaintedTerm::Ptr term) const
-{
-    using namespace std;
-    return find(begin(mTerms), end(mTerms), term) != mTerms.end();
-}
+bool NodeVerticalStack::hasNode(PaintedTerm::Ptr term) const { return rng::find(mTerms, term) != mTerms.end(); }
 
 PaintedTerm::List NodeVerticalStack::nodes() const { return mTerms; }
 
@@ -93,15 +93,10 @@ std::vector<NodeVerticalStack::NodePack> NodeVerticalStack::getNodePacks(const P
 
 void NodeVerticalStack::sortNodePacks(std::vector<NodeVerticalStack::NodePack>& pack)
 {
-    auto order = [](const NodeVerticalStack::NodePack& s1, const NodeVerticalStack::NodePack& s2) {
-        return s1.first.y() < s2.first.y();
-    };
-    std::sort(pack.begin(), pack.end(), order);
-
-    auto innerOrder = [](const PaintedTerm::Ptr t1, const PaintedTerm::Ptr t2) { return t1->term() < t2->term(); };
+    rng::sort(pack, [](const auto& s1, const auto& s2) { return s1.first.y() < s2.first.y(); });
 
-    for ([[maybe_unused]] auto& [pt, nodes] : pack) {
-        std::sort(nodes.begin(), nodes.end(), innerOrder);
+    for (auto& [_, nodes] : pack) {
+        rng::sort(nodes, [](const auto t1, const auto t2) { return t1->term() < t2->term(); });
     }
 }