Changes User id to be it's own type as a template, allowing for constexpr pre C++20 in most cases

JustCallMeRay · JustCallMeRay · commit 8c0d1db70a10 · 2025-07-01T18:53:41.000Z
diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
@@ -39,7 +39,7 @@ jobs:
       # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
       run: |
         if [ ${{ matrix.os }} == 'windows-latest' ]; then
-          cmake -DTEST=ON -Dgtest_disable_pthreads=ON -B ${{github.workspace}}/build
+          cmake -DTEST=ON -Dgtest_disable_pthreads=ON -B ./build
         else
           cmake -DTEST=ON -B ${{github.workspace}}/build
         fi;
diff --git a/.gitignore b/.gitignore
@@ -39,3 +39,5 @@ packaging/
 .vscode
 .code-workspace
 CXXGraph.code-workspace
+# ignore Visual Studio files
+/.vs
diff --git a/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h b/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h
@@ -70,7 +70,7 @@ class DirectedWeightedEdge : public DirectedEdge<T>, public Weighted {
                                      Weighted::getWeight());
   }
 
-  friend std::ostream &operator<< <>(std::ostream &os,
+  friend std::ostream &operator<< (std::ostream &os,
                                      const DirectedWeightedEdge<T> &edge);
 };
 
diff --git a/include/CXXGraph/Edge/Weighted_decl.h b/include/CXXGraph/Edge/Weighted_decl.h
@@ -28,11 +28,11 @@ class Weighted {
   double weight = 0.0;
 
  public:
-  Weighted();
-  explicit Weighted(const double weight);
-  virtual ~Weighted() = default;
-  double getWeight() const;
-  void setWeight(const double weight);
+  constexpr Weighted() noexcept;
+  constexpr explicit Weighted(const double weight) noexcept;
+  virtual ~Weighted() noexcept = default;
+  constexpr double getWeight() const;
+  constexpr void setWeight(const double weight);
 };
 }  // namespace CXXGraph
 
diff --git a/include/CXXGraph/Edge/Weighted_impl.hpp b/include/CXXGraph/Edge/Weighted_impl.hpp
@@ -27,16 +27,19 @@
 namespace CXXGraph {
 
 // inline because the implementation of non-template function in header file
-inline Weighted::Weighted() { weight = 0.0; }
+constexpr Weighted::Weighted() noexcept : weight(0.0) {}
 
 // inline because the implementation of non-template function in header file
-inline Weighted::Weighted(const double weight) { this->weight = weight; }
+constexpr Weighted::Weighted(const double inputWeight) noexcept
+    : weight(inputWeight) {}
 
 // inline because the implementation of non-template function in header file
-inline double Weighted::getWeight() const { return weight; }
+constexpr double Weighted::getWeight() const noexcept { return weight; }
 
 // inline because the implementation of non-template function in header file
-inline void Weighted::setWeight(const double weight) { this->weight = weight; }
+constexpr void Weighted::setWeight(const double weight) {
+  this->weight = weight;
+}
 
 }  // namespace CXXGraph
 
diff --git a/include/CXXGraph/Node/Node_decl.h b/include/CXXGraph/Node/Node_decl.h
@@ -22,38 +22,38 @@
 
 #pragma once
 #include <iostream>
-
+#include <type_traits>
 #include "CXXGraph/Utility/id_t.hpp"
 
 namespace CXXGraph {
-template <typename T>
+template <typename T, typename = std::string>
 class Node;
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const Node<T> &node);
-template <typename T>
+template <typename T, typename UserID>
+std::ostream &operator<<(std::ostream &os, const Node<T, UserID> &node);
+template <typename T, typename UserID>
 class Node {
  private:
   CXXGraph::id_t id = 0;
-  std::string userId = "";
+  UserID userId{};
   T data;
-  void setId(const std::string &);
+  constexpr void setId(const UserID &);
 
  public:
   using Node_t = T;
 
-  Node(const std::string &, const T &data);
+  constexpr Node(const UserID &, const T &data);
   // Move constructor
-  explicit Node(const std::string &, T &&data) noexcept;
-  ~Node() = default;
+  constexpr explicit Node(const UserID &, T &&data) noexcept(std::is_nothrow_move_assignable<T>::value);
+  ~Node() noexcept = default;
   constexpr const CXXGraph::id_t &getId() const;
-  const std::string &getUserId() const;
+  constexpr const UserID &getUserId() const;
   constexpr const T &getData() const;
-  void setData(T &&new_data);
+  constexpr void setData(T &&new_data);
   // operator
-  constexpr bool operator==(const Node<T> &b) const;
-  constexpr bool operator<(const Node<T> &b) const;
+  constexpr bool operator==(const Node<T, UserID> &b) const;
+  constexpr bool operator<(const Node<T, UserID> &b) const;
   
-  friend std::ostream &operator<< <>(std::ostream &os, const Node<T> &node);
+  friend std::ostream &operator<< <>(std::ostream &os, const Node<T, UserID> &node);
 };
 
 }  // namespace CXXGraph
diff --git a/include/CXXGraph/Node/Node_impl.hpp b/include/CXXGraph/Node/Node_impl.hpp
@@ -20,71 +20,117 @@
 #ifndef __CXXGRAPH_NODE_IMPL_H__
 #define __CXXGRAPH_NODE_IMPL_H__
 
+#if __cplusplus >= 202004L
+#include <bitset>
+#else
+#include <cstring>
+#endif
+
 #include <iomanip>
+#include <limits>
+#include <type_traits>
 
 #include "Node_decl.h"
 
 namespace CXXGraph {
+// internals not intended to be accessed by the end user
+namespace internals {
+template <typename AnyUserID>
+constexpr CXXGraph::id_t UserIdToId(const AnyUserID &id) {
+  // in C++ 23 we have constexpr hashes
+  if constexpr (__cplusplus >= 202302L) return std::hash<AnyUserID>{}(id);
+  // hashing is trivial for integral types
+  if constexpr (std::is_integral<AnyUserID>::value) {
+    // assert nothing is greater than a size_t to avoid issues with GCC and
+    // clang's 128 bit ints, a size_t is usually 64 bits
+    static_assert(std::numeric_limits<CXXGraph::id_t>::max() >=
+                  std::numeric_limits<AnyUserID>::max());
+
+    if constexpr (std::is_signed<AnyUserID>::value) {
+      // Add id to half max so that we have something unique
+      return (std::numeric_limits<CXXGraph::id_t>::max() / 2) + id;
+    }
+    return static_cast<CXXGraph::id_t>(id);
+  }
+  // typepun the float into an int
+  if constexpr (std::is_floating_point<AnyUserID>::value) {
+    // static assert to avoid long double (80 bits rather than 64)
+    static_assert(sizeof(CXXGraph::id_t) >= sizeof(AnyUserID));
+// In C++20 we can do typepunning at compile time
+#if __cplusplus >= 202004L
+    return std::bit_cast<CXXGraph::id_t>(id);
+#else   // < C++20
+    // otherwise use memcpy (not compile time)
+    CXXGraph::id_t result{};
+    std::memcpy(&result, &id, sizeof(id));
+    return result;
+#endif  // >= C++20
+  }
+  // resort back to runtime hash
+  return std::hash<AnyUserID>{}(id);
+}
+}  // namespace internals
 
-template <typename T>
+template <typename T, typename UserID>
 class Node;
 
-template <typename T>
-Node<T>::Node(const std::string &id, const T &data) {
-  this->userId = id;
-  // the userid is set as sha512 hash of the user provided id
-  setId(id);
-  this->data = data;
+template <typename T, typename UserID>
+constexpr Node<T, UserID>::Node(const UserID &otherId, const T &otherData)
+    : id(internals::UserIdToId(otherId)), userId(otherId), data(otherData) {
+  static_assert(
+      !std::is_pointer<UserID>::value,
+      "Pointer is not allowed as an ID type, did you mean std::string?");
 }
 
-template <typename T>
-Node<T>::Node(const std::string &id, T &&data) noexcept {
-  this->userId = id;
-  // the userid is set as sha512 hash of the user provided id
-  setId(id);
-  this->data = std::move(data);
+template <typename T, typename UserID>
+constexpr Node<T, UserID>::Node(const UserID &otherId, T &&otherData) noexcept(
+    std::is_nothrow_move_assignable<T>::value)
+    : id(internals::UserIdToId(otherId)), userId(otherId), data(otherData) {
+  static_assert(
+      !std::is_pointer<UserID>::value,
+      "Pointer is not allowed as an ID type, did you mean std::string?");
 }
 
-template <typename T>
-void Node<T>::setId(const std::string &inpId) {
-  this->id = std::hash<std::string>{}(inpId);
+template <typename T, typename UserID>
+constexpr void Node<T, UserID>::setId(const UserID &inputId) {
+  this->id = UserIdToId(inputId);
 }
 
-template <typename T>
-constexpr const CXXGraph::id_t &Node<T>::getId() const {
+template <typename T, typename UserID>
+constexpr const CXXGraph::id_t &Node<T, UserID>::getId() const {
   return id;
 }
 
-template <typename T>
-const std::string &Node<T>::getUserId() const {
+template <typename T, typename UserID>
+constexpr const UserID &Node<T, UserID>::getUserId() const {
   return userId;
 }
 
-template <typename T>
-constexpr const T &Node<T>::getData() const {
+template <typename T, typename UserID>
+constexpr const T &Node<T, UserID>::getData() const {
   return data;
 }
 
-template <typename T>
-void Node<T>::setData(T &&new_data) {
-  this->data = std::move(new_data);
+template <typename T, typename UserID>
+constexpr void Node<T, UserID>::setData(T &&newData) {
+  this->data = std::move(newData);
 }
 
 // The data type T must have an overload of the equality operator
-template <typename T>
-constexpr bool Node<T>::operator==(const Node<T> &b) const {
+template <typename T, typename UserID>
+constexpr bool Node<T, UserID>::operator==(const Node<T, UserID> &b) const {
   return (this->id == b.id && this->data == b.data);
 }
 
-template <typename T>
-constexpr bool Node<T>::operator<(const Node<T> &b) const {
+template <typename T, typename UserID>
+constexpr bool Node<T, UserID>::operator<(const Node<T, UserID> &b) const {
   return (this->id < b.id);
 }
 
 // ostream overload
 // The data type T must have an overload of the ostream operator
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const Node<T> &node) {
+template <typename T, typename UserID>
+std::ostream &operator<<(std::ostream &os, const Node<T, UserID> &node) {
   os << "Node: {\n"
      << "  Id:\t" << node.userId << "\n  Data:\t" << node.data << "\n}";
   return os;
diff --git a/include/CXXGraph/Utility/Typedef.hpp b/include/CXXGraph/Utility/Typedef.hpp
@@ -36,7 +36,7 @@ namespace CXXGraph {
 template <typename T>
 using shared = std::shared_ptr<T>;
 
-template <typename T>
+template <typename T, typename UserID>
 class Node;
 
 template <typename T>
diff --git a/test/ConstexprTests.cpp b/test/ConstexprTests.cpp
@@ -0,0 +1,26 @@
+
+#include <memory>
+
+#include "CXXGraph/CXXGraph.hpp"
+#include "gtest/gtest.h"
+
+// Boolean results will always be true
+//  functions are only here to test that this compiles
+constexpr bool IsConstexprContextCreateable() {
+	CXXGraph::Node<int, size_t> node1(1, 1);
+	return true;
+}
+
+constexpr bool IsConstexprCreateable() {
+	constexpr CXXGraph::Node<int, size_t> node1(1, 1);
+	return true;
+}
+
+
+TEST(ConstexprTests, IsConstexprContextCreateable) {
+	ASSERT_TRUE(IsConstexprContextCreateable());
+}
+
+TEST(ConstexprTests, IsConstexprCreateable) {
+	ASSERT_TRUE(IsConstexprCreateable());
+}

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ class DirectedWeightedEdge : public DirectedEdge<T>, public Weighted {`
`70`	`70`	`Weighted::getWeight());`
`71`	`71`	`}`
`72`	`72`
`73`		`- friend std::ostream &operator<< <>(std::ostream &os,`
	`73`	`+ friend std::ostream &operator<< (std::ostream &os,`
`74`	`74`	`const DirectedWeightedEdge<T> &edge);`
`75`	`75`	`};`
`76`	`76`