Adds constexpr to more types, edges

ZigRazor · Jan 6, 2025 · f2543eb · f2543eb
1 parent 49888f5
commit f2543eb
Show file tree

Hide file tree

Showing 6 changed files with 69 additions and 69 deletions.
diff --git a/include/CXXGraph/Edge/DirectedEdge_decl.h b/include/CXXGraph/Edge/DirectedEdge_decl.h
@@ -17,8 +17,8 @@
 /***	 License: MPL v2.0 ***/
 /***********************************************************/
 
-#ifndef __CXXGRAPH_DIRECTEDEDGE_DECL_H__
-#define __CXXGRAPH_DIRECTEDEDGE_DECL_H__
+#ifndef CXXGRAPH_DIRECTEDEDGE_DECL_H_
+#define CXXGRAPH_DIRECTEDEDGE_DECL_H_
 
 #pragma once
 
@@ -42,19 +42,21 @@ std::ostream &operator<<(std::ostream &o, const DirectedEdge<T> &edge);
 template <typename T>
 class DirectedEdge : public Edge<T> {
  public:
-  DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+  constexpr DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
                const Node<T> &node2);
-  DirectedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr DirectedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
                shared<const Node<T>> node2);
-  DirectedEdge(const CXXGraph::id_t id,
+  constexpr DirectedEdge(
+      const CXXGraph::id_t id,
                const std::pair<const Node<T> *, const Node<T> *> &nodepair);
-  DirectedEdge(
+  constexpr DirectedEdge(
       const CXXGraph::id_t id,
       const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair);
-  DirectedEdge(const Edge<T> &edge);
+  constexpr DirectedEdge(const Edge<T> &edge);
   virtual ~DirectedEdge() = default;
-  const Node<T> &getFrom() const;
-  const Node<T> &getTo() const;
+  constexpr const Node<T> &getFrom() const;
+  constexpr const Node<T> &getTo() const;
+  // 
   const std::optional<bool> isDirected() const override;
   const std::optional<bool> isWeighted() const override;
   // operator
@@ -67,4 +69,4 @@ class DirectedEdge : public Edge<T> {
 };
 }  // namespace CXXGraph
 
-#endif  // __CXXGRAPH_DIRECTEDEDGE_H__
+#endif  // CXXGRAPH_DIRECTEDEDGE_H_
diff --git a/include/CXXGraph/Edge/DirectedEdge_impl.hpp b/include/CXXGraph/Edge/DirectedEdge_impl.hpp
@@ -26,44 +26,42 @@
 
 namespace CXXGraph {
 
-using std::make_shared;
-using std::make_unique;
-
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+constexpr DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
+                                       const Node<T> &node1,
                               const Node<T> &node2)
     : Edge<T>(id, node1, node2) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
+constexpr DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
                               shared<const Node<T>> node1,
                               shared<const Node<T>> node2)
     : Edge<T>(id, node1, node2) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(
+constexpr DirectedEdge<T>::DirectedEdge(
     const CXXGraph::id_t id,
     const std::pair<const Node<T> *, const Node<T> *> &nodepair)
     : Edge<T>(id, nodepair) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(
+constexpr DirectedEdge<T>::DirectedEdge(
     const CXXGraph::id_t id,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair)
     : Edge<T>(id, nodepair) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const Edge<T> &edge)
+constexpr DirectedEdge<T>::DirectedEdge(const Edge<T> &edge)
     : DirectedEdge(edge.getId(), *(edge.getNodePair().first),
                    *(edge.getNodePair().second)) {}
 
 template <typename T>
-const Node<T> &DirectedEdge<T>::getFrom() const {
+constexpr const Node<T> &DirectedEdge<T>::getFrom() const {
   return *(Edge<T>::getNodePair().first);
 }
 
 template <typename T>
-const Node<T> &DirectedEdge<T>::getTo() const {
+constexpr const Node<T> &DirectedEdge<T>::getTo() const {
   return *(Edge<T>::getNodePair().second);
 }
 

diff --git a/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h b/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h
@@ -45,23 +45,25 @@ std::ostream &operator<<(std::ostream &o, const DirectedWeightedEdge<T> &edge);
 template <typename T>
 class DirectedWeightedEdge : public DirectedEdge<T>, public Weighted {
  public:
-  DirectedWeightedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+  constexpr DirectedWeightedEdge(const CXXGraph::id_t id, const Node<T> &node1,
                        const Node<T> &node2, const double weight);
-  DirectedWeightedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr DirectedWeightedEdge(const CXXGraph::id_t id,
+                                 shared<const Node<T>> node1,
                        shared<const Node<T>> node2, const double weight);
-  DirectedWeightedEdge(
+  constexpr DirectedWeightedEdge(
       const CXXGraph::id_t id,
       const std::pair<const Node<T> *, const Node<T> *> &nodepair,
       const double weight);
-  DirectedWeightedEdge(
+  constexpr DirectedWeightedEdge(
       const CXXGraph::id_t id,
       const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair,
       const double weight);
-  DirectedWeightedEdge(const DirectedEdge<T> &edge, const double weight);
-  DirectedWeightedEdge(const Edge<T> &edge, const double weight);
-  DirectedWeightedEdge(const DirectedEdge<T> &edge);
-  DirectedWeightedEdge(const Edge<T> &edge);
-  DirectedWeightedEdge(const UndirectedWeightedEdge<T> &edge);
+  constexpr DirectedWeightedEdge(const DirectedEdge<T> &edge,
+                                 const double weight);
+  constexpr DirectedWeightedEdge(const Edge<T> &edge, const double weight);
+  constexpr DirectedWeightedEdge(const DirectedEdge<T> &edge);
+  constexpr DirectedWeightedEdge(const Edge<T> &edge);
+  constexpr DirectedWeightedEdge(const UndirectedWeightedEdge<T> &edge);
   virtual ~DirectedWeightedEdge() = default;
   const std::optional<bool> isWeighted() const override;
   // operator

diff --git a/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp b/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp
@@ -27,53 +27,56 @@
 namespace CXXGraph {
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
                                               const Node<T> &node1,
                                               const Node<T> &node2,
                                               const double weight)
     : DirectedEdge<T>(id, node1, node2), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const CXXGraph::id_t id,
                                               shared<const Node<T>> node1,
                                               shared<const Node<T>> node2,
                                               const double weight)
     : DirectedEdge<T>(id, node1, node2), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const CXXGraph::id_t id,
     const std::pair<const Node<T> *, const Node<T> *> &nodepair,
     const double weight)
     : DirectedEdge<T>(id, nodepair), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const CXXGraph::id_t id,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair,
     const double weight)
     : DirectedEdge<T>(id, nodepair), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const DirectedEdge<T> &edge,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const DirectedEdge<T> &edge,
                                               const double weight)
     : DirectedEdge<T>(edge), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge,
                                               const double weight)
     : DirectedEdge<T>(edge), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const DirectedEdge<T> &edge)
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const DirectedEdge<T> &edge)
     : DirectedEdge<T>(edge), Weighted() {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge)
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge)
     : DirectedEdge<T>(edge), Weighted() {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const UndirectedWeightedEdge<T> &edge)
     : DirectedEdge<T>(edge), Weighted(edge.getWeight()) {}
 

diff --git a/include/CXXGraph/Edge/Edge_decl.h b/include/CXXGraph/Edge/Edge_decl.h
@@ -49,25 +49,26 @@ class Edge {
  public:
   typedef T Node_t;
 
-  Edge(const CXXGraph::id_t id, const Node<T> &node1, const Node<T> &node2);
-  Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr Edge(const CXXGraph::id_t id, const Node<T> &node1, const Node<T> &node2);
+  constexpr Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
        shared<const Node<T>> node2);
-  Edge(const CXXGraph::id_t id,
+  constexpr Edge(const CXXGraph::id_t id,
        const std::pair<const Node<T> *, const Node<T> *> &nodepair);
-  Edge(const CXXGraph::id_t id,
+  constexpr Edge(
+      const CXXGraph::id_t id,
        const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair);
   virtual ~Edge() = default;
   void setFirstNode(shared<const Node<T>> node);
   void setSecondNode(shared<const Node<T>> node);
-  unsigned long long getId() const;
+  constexpr unsigned long long getId() const;
   const std::pair<shared<const Node<T>>, shared<const Node<T>>> &getNodePair()
       const;
   shared<const Node<T>> getOtherNode(shared<const Node<T>> node) const;
   virtual const std::optional<bool> isDirected() const;
   virtual const std::optional<bool> isWeighted() const;
   // operator
   virtual bool operator==(const Edge<T> &b) const;
-  bool operator<(const Edge<T> &b) const;
+  constexpr bool operator<(const Edge<T> &b) const;
 
   friend std::ostream &operator<< <>(std::ostream &os, const Edge<T> &edge);
 };

diff --git a/include/CXXGraph/Edge/Edge_impl.hpp b/include/CXXGraph/Edge/Edge_impl.hpp
@@ -35,36 +35,30 @@ using std::make_shared;
 using std::make_unique;
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id, const Node<T> &node1,
-              const Node<T> &node2) {
-  this->nodePair.first = make_shared<const Node<T>>(node1);
-  this->nodePair.second = make_shared<const Node<T>>(node2);
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId, const Node<T> &node1,
+              const Node<T> &node2)
+    : id(otherId), nodePair{std::make_shared<const Node<T>>(node1),
+               std::make_shared<const Node<T>>(node2)}
+      {}
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
-              shared<const Node<T>> node2) {
-  this->nodePair.first = node1;
-  this->nodePair.second = node2;
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId, shared<const Node<T>> node1,
+              shared<const Node<T>> node2)
+    : id(otherId), nodePair(node1, node2) {}
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id,
-              const std::pair<const Node<T> *, const Node<T> *> &nodepair) {
-  this->nodePair.first = make_shared<const Node<T>>(*(nodepair.first));
-  this->nodePair.second = make_shared<const Node<T>>(*(nodepair.second));
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId,
+              const std::pair<const Node<T> *, const Node<T> *> &nodepair) 
+    : id(otherId) 
+    , nodePair(std::make_shared<const Node<T>>(*(nodepair.first)),
+                           std::make_shared<const Node<T>>(*(nodepair.second)))
+{ }
 
 template <typename T>
-Edge<T>::Edge(
-    const CXXGraph::id_t id,
+constexpr Edge<T>::Edge(
+    const CXXGraph::id_t otherId,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair)
-    : nodePair(nodepair) {
-  this->id = id;
-}
+    : id(otherId), nodePair(nodepair) { }
 
 template <typename T>
 void Edge<T>::setFirstNode(shared<const Node<T>> node) {
@@ -79,7 +73,7 @@ void Edge<T>::setSecondNode(shared<const Node<T>> node) {
 }
 
 template <typename T>
-unsigned long long Edge<T>::getId() const {
+constexpr unsigned long long Edge<T>::getId() const {
   return id;
 }
 
@@ -114,7 +108,7 @@ bool Edge<T>::operator==(const Edge<T> &b) const {
 }
 
 template <typename T>
-bool Edge<T>::operator<(const Edge<T> &b) const {
+constexpr bool Edge<T>::operator<(const Edge<T> &b) const {
   return (this->id < b.id);
 }