handle: extract handle-related code from dsc.h

This makes it easier to avoid including dsc.h when it's not needed.

Author: iscgar

src/CMakeLists.txt

@@ -65,6 +65,7 @@ add_library(slvs-solver INTERFACE)
 target_sources(slvs-solver INTERFACE
     dsc.h
     expr.h
+    handle.h
     param.h
     platform/platform.h
     solvespace.h

src/dsc.h

@@ -11,50 +11,13 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <type_traits>
 #include <vector>
 
 #include "defs.h"
 #include "util.h"
 
 namespace SolveSpace {
 
-/// Trait indicating which types are handle types and should get the associated operators.
-/// Specialize for each handle type and inherit from std::true_type.
-template<typename T>
-struct IsHandleOracle : std::false_type {};
-
-// Equality-compare any two instances of a handle type.
-template<typename T>
-static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
-operator==(T const &lhs, T const &rhs) {
-    return lhs.v == rhs.v;
-}
-
-// Inequality-compare any two instances of a handle type.
-template<typename T>
-static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
-operator!=(T const &lhs, T const &rhs) {
-    return !(lhs == rhs);
-}
-
-// Less-than-compare any two instances of a handle type.
-template<typename T>
-static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
-operator<(T const &lhs, T const &rhs) {
-    return lhs.v < rhs.v;
-}
-
-template<class T>
-struct HandleHasher {
-    static_assert(IsHandleOracle<T>::value, "Not a valid handle type");
-
-    inline size_t operator()(const T &h) const {
-        using Hasher = std::hash<decltype(T::v)>;
-        return Hasher{}(h.v);
-    }
-};
-
 class Vector;
 class Vector4;
 class Point2d;

src/handle.h

@@ -0,0 +1,47 @@
+#ifndef SOVLESPACE_HANDLE_H
+#define SOVLESPACE_HANDLE_H
+
+#include <functional>
+#include <type_traits>
+
+namespace SolveSpace {
+
+/// Trait indicating which types are handle types and should get the associated operators.
+/// Specialize for each handle type and inherit from std::true_type.
+template<class T>
+struct IsHandleOracle : std::false_type {};
+
+// Equality-compare any two instances of a handle type.
+template<class T>
+static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
+operator==(T const &lhs, T const &rhs) {
+    return lhs.v == rhs.v;
+}
+
+// Inequality-compare any two instances of a handle type.
+template<class T>
+static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
+operator!=(T const &lhs, T const &rhs) {
+    return !(lhs == rhs);
+}
+
+// Less-than-compare any two instances of a handle type.
+template<class T>
+static inline typename std::enable_if<IsHandleOracle<T>::value, bool>::type
+operator<(T const &lhs, T const &rhs) {
+    return lhs.v < rhs.v;
+}
+
+template<class T>
+struct HandleHasher {
+    static_assert(IsHandleOracle<T>::value, "Not a valid handle type");
+
+    inline size_t operator()(const T &h) const {
+        using Hasher = std::hash<decltype(T::v)>;
+        return Hasher{}(h.v);
+    }
+};
+
+} // namespace SolveSpace
+
+#endif // !SOVLESPACE_HANDLE_H

src/param.h

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <unordered_set>
 
-#include "dsc.h"
+#include "handle.h"
 
 namespace SolveSpace {
 
@@ -39,7 +39,11 @@ class Param {
     void Clear() {}
 };
 
-using ParamList = IdList<Param,hParam>;
+// Use a forward declaration in order to avoid pulling dsc.h in for units that
+// don't need to use `ParamList`
+template<class T, class H> class IdList;
+
+using ParamList = IdList<Param, hParam>;
 
 using ParamSet = std::unordered_set<hParam, HandleHasher<hParam>>;
 

src/srf/surface.h

@@ -13,6 +13,7 @@
 #include <cstdint>
 
 #include "dsc.h"
+#include "handle.h"
 #include "polygon.h"
 
 namespace SolveSpace {