[Rmv] inline destructor error, fix code quality in GraphView

include/aidge/graphRegex/GraphParser.hpp

@@ -21,8 +21,6 @@ class GraphParser{
      */
     GraphParser(const std::string gRegexExpressions);
 
-    virtual ~GraphParser() = default;
-
     /**
      * @brief AST graph creation function
      * @return The AST tree
@@ -31,7 +29,7 @@ class GraphParser{
 
 
     /**
-     * @brief get the query that be use in the parsing 
+     * @brief get the query that be use in the parsing
      * @return query
      */
     const std::string getQuery();

include/aidge/graphRegex/matchFsm/MatchResult.hpp

 #ifndef AIDGE_CORE_MATCH_RESULT_H_
 #define AIDGE_CORE_MATCH_RESULT_H_
 
+#include <cstddef>
+#include <map>
 #include <memory>
+#include <string>
+#include <set>
 #include <vector>
-#include <map>
-
 
 #include "aidge/graphRegex/matchFsm/FsmRunTimeContext.hpp"
 #include "aidge/graph/Node.hpp"
@@ -12,23 +14,25 @@
 namespace Aidge{
 
 /**
- * @brief contained the result of one match and the associate key , the query and the start node 
+ * @brief contained the result of one match and the associate key , the query and the start node
 */
 
 class MatchSolution{
 private:
-    std::map<std::string,std::set<NodePtr>> mSolution;
+    std::map<std::string, std::set<NodePtr>> mSolution;
     const std::string mQueryFrom;
     const std::vector<NodePtr> mStartNode;
 
 public:
     MatchSolution(std::vector<std::shared_ptr<FsmRunTimeContext>>& precedence,const std::string query,const std::vector<NodePtr> startNode);
-    const std::set<NodePtr> & at(const std::string key);
-    const std::set<NodePtr>  getAll();
+    inline const std::set<NodePtr>& at(const std::string key) {
+        return mSolution[key];
+    }
+    const std::set<NodePtr> getAll();
     bool areCompatible(std::shared_ptr<MatchSolution> solution);
 
-    const std::string& getQuery(){ return mQueryFrom ;}
-    const std::vector<NodePtr>& getStartNode(){ return mStartNode ;}
+    inline const std::string& getQuery() const noexcept { return mQueryFrom; }
+    inline const std::vector<NodePtr>& getStartNode() const noexcept { return mStartNode; }
 
 };
 
@@ -59,15 +63,15 @@ public:
     MatchResult(std::vector<std::shared_ptr<FsmRunTimeContext>> allValid, std::size_t nbSubStm,
      const std::string& query,const std::vector<NodePtr>& startNodes);
 
-    virtual ~MatchResult() = default;
-
     /**
      * @brief get the set of the node match for une expression
      * @return the set of node of the graph that corresponding to an expression
     */
     std::shared_ptr<MatchSolution> getBiggerSolution(void);
 
-    std::vector<std::shared_ptr<MatchSolution>> getSolutions(void);
+    inline std::vector<std::shared_ptr<MatchSolution>> getSolutions(void) const noexcept {
+        return mSolve;
+    }
 
 private:
 
@@ -75,7 +79,6 @@ private:
  * @brief recurrent function use to init mSolve in the constructor
  *
  **/
-
 void _generateCombination( std::size_t idxSubStm, std::vector<std::shared_ptr<FsmRunTimeContext>>& precedence,const std::string& query,const std::vector<NodePtr>& startNodes);
 
 };

include/aidge/nodeTester/ConditionalParser.hpp

@@ -38,7 +38,6 @@ class ConditionalParser{
      */
     ConditionalParser(const std::string ConditionalExpressions);
 
-    virtual ~ConditionalParser() = default;
     /**
      * @brief AST graph creation function
      * @return The AST tree

include/aidge/operator/Operator.hpp

@@ -68,7 +68,7 @@ public:
         // Hooks are not copied.
     }
 
-    virtual ~Operator();
+    virtual ~Operator() noexcept;
 
 public:
     virtual std::shared_ptr<Operator> clone() const = 0;

include/aidge/operator/OperatorTensor.hpp

@@ -61,7 +61,7 @@ public:
         }
     }
 
-    virtual ~OperatorTensor() = default;
+    ~OperatorTensor();
 
 public:
     ///////////////////////////////////////////////////

src/graph/GraphView.cpp

@@ -13,6 +13,7 @@
 #include <cassert>
 #include <iterator>
 #include <utility>
+#include <numeric>
 
 #include "aidge/utils/Types.h"
 #include "aidge/graph/GraphView.hpp"
@@ -108,20 +109,19 @@ void Aidge::GraphView::save(std::string path, bool verbose) const {
 ///////////////////////////////////////////////////////
 
 Aidge::IOIndex_t Aidge::GraphView::getNbDataInputs() const {
-  IOIndex_t nbDataInput = 0;
-  // assert(outputNodes().size() == static_cast<std::size_t>(1));
-  for (const std::shared_ptr<Node> &inNode : inputNodes()) {
-    nbDataInput += inNode->nbData();
-  }
-  return nbDataInput;
+    return std::accumulate(mInputNodes.cbegin(), mInputNodes.cend(), 0,
+                            [](IOIndex_t sumData, const std::shared_ptr<Node> inNode) {
+                                return sumData + inNode->nbData();
+                            }
+                        );
 }
 
 Aidge::IOIndex_t Aidge::GraphView::getNbFreeDataInputs() const {
-  IOIndex_t nbIn = 0;
-  for (const std::shared_ptr<Node>& inputNode : mInputNodes) {
-    nbIn += inputNode->getNbFreeDataInputs();
-  }
-  return nbIn;
+  return std::accumulate(mInputNodes.cbegin(), mInputNodes.cend(), 0,
+                            [](IOIndex_t sumData, const std::shared_ptr<Node> inNode) {
+                                return sumData + inNode->getNbFreeDataInputs();
+                            }
+                        );
 }
 
 

src/graphRegex/matchFsm/MatchResult.cpp

+#include <algorithm> // set_intersection, std::sort
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
 #include "aidge/graphRegex/matchFsm/MatchResult.hpp"
 
-using namespace Aidge; 
-
-    MatchSolution::MatchSolution(std::vector<std::shared_ptr<FsmRunTimeContext>>& precedence,const std::string query,const std::vector<NodePtr> startNode):mQueryFrom(query),mStartNode(startNode){
-            //reformat the solution
-            for (const auto& context : precedence) {
-                for (const auto& pair : context->getValid()) {
-                    
-                    if(mSolution.find(pair.first->getKey()) == mSolution.end()){
-                        mSolution[pair.first->getKey()] = pair.second;
-                    }else{
-                         mSolution[pair.first->getKey()].insert(pair.second.begin(), pair.second.end());
-                    }
+Aidge::MatchSolution::MatchSolution(std::vector<std::shared_ptr<FsmRunTimeContext>>& precedence,const std::string query,const std::vector<NodePtr> startNode):mQueryFrom(query),mStartNode(startNode){
+        //reformat the solution
+        for (const auto& context : precedence) {
+            for (const auto& pair : context->getValid()) {
+
+                if(mSolution.find(pair.first->getKey()) == mSolution.end()){
+                    mSolution[pair.first->getKey()] = pair.second;
+                }else{
+                        mSolution[pair.first->getKey()].insert(pair.second.begin(), pair.second.end());
                 }
             }
-    }
-
-
-    const std::set<NodePtr> & MatchSolution::at(const std::string key){
-
-        return mSolution[key];
+        }
+}
 
-    }
+const std::set<Aidge::NodePtr> Aidge::MatchSolution::getAll(){
 
-    const std::set<NodePtr> MatchSolution::getAll(){
+        // Create a unique set to store all the elements
+        std::set<NodePtr> uniqueSet;
 
-            // Create a unique set to store all the elements
-            std::set<NodePtr> uniqueSet;
+        // Iterate through the map and insert elements from each set into the unique set
+        for (const auto& pair : mSolution) {
+            const std::set<NodePtr>& nodeSet = pair.second;
 
-            // Iterate through the map and insert elements from each set into the unique set
-            for (const auto& pair : mSolution) {
-                const std::set<NodePtr>& nodeSet = pair.second;
-                
-                // Insert elements from the current set into the unique set
-                uniqueSet.insert(nodeSet.begin(), nodeSet.end());
-            }
-            
-            return uniqueSet;
+            // Insert elements from the current set into the unique set
+            uniqueSet.insert(nodeSet.begin(), nodeSet.end());
+        }
 
-    }
+        return uniqueSet;
+}
 
-    bool MatchSolution::areCompatible(std::shared_ptr<MatchSolution> solution){
-        std::set<NodePtr> set1 = solution->getAll();
-        std::set<NodePtr> set2 = getAll();
-        std::set<NodePtr> intersection ;
-        std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(intersection, intersection.begin()));
-        if (intersection.empty()) {
-            return true;
-        }
-        return false;
-    }
+bool Aidge::MatchSolution::areCompatible(std::shared_ptr<Aidge::MatchSolution> solution){
+    std::set<NodePtr> set1 = solution->getAll();
+    std::set<NodePtr> set2 = getAll();
+    std::set<NodePtr> intersection ;
+    std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(intersection, intersection.begin()));
+    return intersection.empty();
+}
 
-    
 
 ////////////////////////////////
 //
 ////////////////////////////////
-MatchResult::MatchResult(std::vector<std::shared_ptr<FsmRunTimeContext>> allValid, std::size_t nbSubStm,
-const std::string& query,const std::vector<NodePtr>& startNodes):mIdToRunTime(nbSubStm),mNbSubStm(nbSubStm){
-        mAllValid = allValid;
-
-        //mIdToRunTimm
-        for (const auto& contextPtr : allValid) {
-            mIdToRunTime[contextPtr->getSubStmId()].push_back(contextPtr);
-        }
+Aidge::MatchResult::MatchResult(std::vector<std::shared_ptr<Aidge::FsmRunTimeContext>> allValid,
+                                std::size_t nbSubStm,
+                                const std::string& query,
+                                const std::vector<Aidge::NodePtr>& startNodes)
+        : mIdToRunTime(nbSubStm),
+          mNbSubStm(nbSubStm)
+{
+    mAllValid = allValid;
+
+    //mIdToRunTimm
+    for (const auto& contextPtr : allValid) {
+        mIdToRunTime[contextPtr->getSubStmId()].push_back(contextPtr);
+    }
 
-        std::vector<std::shared_ptr<FsmRunTimeContext>> precedence;
-        //make all solution possible 
-        _generateCombination(0,precedence,query,startNodes);
-        //sort by solution number of elements
-        std::sort(mSolve.begin(), mSolve.end(), [](std::shared_ptr<MatchSolution>& set1, std::shared_ptr<MatchSolution>& set2) {
+    std::vector<std::shared_ptr<FsmRunTimeContext>> precedence;
+    //make all solution possible
+    _generateCombination(0,precedence,query,startNodes);
+    //sort by solution number of elements
+    std::sort(mSolve.begin(), mSolve.end(), [](std::shared_ptr<MatchSolution>& set1, std::shared_ptr<MatchSolution>& set2) {
         return set1->getAll().size() < set2->getAll().size();
-        });
-
-
+    });
 }
 
-void MatchResult::_generateCombination( std::size_t idxSubStm, std::vector<std::shared_ptr<FsmRunTimeContext>>& precedence,
-const std::string& query,const std::vector<NodePtr>& startNodes){
-
+void Aidge::MatchResult::_generateCombination( std::size_t idxSubStm,
+                                        std::vector<std::shared_ptr<Aidge::FsmRunTimeContext>>& precedence,
+                                        const std::string& query,
+                                        const std::vector<Aidge::NodePtr>& startNodes)
+{
     //it's end , we are below the number of stm
     if (idxSubStm == mNbSubStm)
     {
-        //precedence contain a list of FSM compatible, we just need to 
-        //check if all the nodes have been validated by at least one context 
-        
+        //precedence contain a list of FSM compatible, we just need to
+        //check if all the nodes have been validated by at least one context
+
         //1) make the set of all node for the compute graph that are valid in all the  FsmRunTimeContext
         std::set<NodePtr> validNode;
         std::set<NodePtr> rejectNode;
@@ -94,10 +91,10 @@ const std::string& query,const std::vector<NodePtr>& startNodes){
             std::set<NodePtr> tmpR =  contextPtr->getRejectedNodes();
             rejectNode.insert(tmpR.begin(),tmpR.end());
         }
-        // 2) all  RejectedNodes need to be valid by an others stm 
+        // 2) all  RejectedNodes need to be valid by an others stm
         // if it's not the case the match is not valid
         if(std::includes(validNode.begin(), validNode.end(), rejectNode.begin(), rejectNode.end())){
-            //we can save the solution 
+            //we can save the solution
             mSolve.push_back(std::make_shared<MatchSolution>(precedence,query,startNodes));
         }
         precedence.pop_back();
@@ -105,12 +102,12 @@ const std::string& query,const std::vector<NodePtr>& startNodes){
     }
 
 
-    for (const auto& contextPtrOneFsm : mIdToRunTime[idxSubStm]) 
+    for (const auto& contextPtrOneFsm : mIdToRunTime[idxSubStm])
     {
         if(idxSubStm == 0){
             precedence.push_back(contextPtrOneFsm);
             _generateCombination(idxSubStm+1,precedence,query,startNodes);
-            
+
         }else{
             //test if the new context is compatible with all the context in the precedence
             //
@@ -137,16 +134,6 @@ const std::string& query,const std::vector<NodePtr>& startNodes){
 
 }
 
-std::shared_ptr<MatchSolution> MatchResult::getBiggerSolution(void){
-
-    if(mSolve.empty()){
-        return nullptr;
-    }else{
-        return mSolve[0];
-    }
-    
-}
-
-std::vector<std::shared_ptr<MatchSolution>> MatchResult::getSolutions(void){
-    return mSolve;
+std::shared_ptr<Aidge::MatchSolution> Aidge::MatchResult::getBiggerSolution(void){
+    return mSolve.empty() ? nullptr : mSolve[0];
 }
\ No newline at end of file

src/operator/Operator.cpp

@@ -25,7 +25,7 @@
 // 	// ctor
 // }
 
-Aidge::Operator::~Operator() = default;
+Aidge::Operator::~Operator() noexcept = default;
 
 ///////////////////////////////////////////////////////
 //        IMPLEMENTATION

src/operator/OperatorTensor.cpp

@@ -40,6 +40,8 @@ void Aidge::OperatorTensor::setInput(const Aidge::IOIndex_t inputIdx, const std:
     }
 }
 
+Aidge::OperatorTensor::~OperatorTensor() = default;
+
 void Aidge::OperatorTensor::setInput(const Aidge::IOIndex_t inputIdx, std::shared_ptr<Aidge::Data>&& data) {
     if (strcmp(data->type(), "Tensor") != 0) {
         AIDGE_THROW_OR_ABORT(std::runtime_error, "%s Operator only accepts Tensors as inputs", type().c_str());