Better concepts for psyqo's Fragment and fixed points.

src/mips/psyqo/fixed-point.hh

@@ -62,6 +62,7 @@ void printInt(uint32_t value, const eastl::function<void(char)>&, unsigned preci
  * @tparam T The underlying integer type to use.
  */
 template <unsigned precisionBits = 12, std::integral T = int32_t>
+requires((precisionBits > 0) && (precisionBits < 32) && ((sizeof(T) == 4) || (sizeof(T) == 2)))
 class FixedPoint {
     using signedUpType = std::conditional<sizeof(T) == 4, int64_t, int32_t>::type;
     using unsignedUpType = std::conditional<sizeof(T) == 4, uint64_t, uint32_t>::type;
@@ -89,8 +90,7 @@ class FixedPoint {
      * fraction.
      */
     explicit constexpr FixedPoint(T integer, T fraction) : value(integer * scale + fraction) {
-        static_assert(sizeof(T) == 4 || sizeof(T) == 2);
-        static_assert(precisionBits > 0);
+        static_assert(sizeof(FixedPoint) == sizeof(T));
     }
 
     /**

src/mips/psyqo/fragment-concept.hh

@@ -28,9 +28,18 @@ SOFTWARE.
 
 #include <concepts>
 #include <cstddef>
+#include <type_traits>
 
 namespace psyqo {
 
+template <typename T, class Enable = void>
+struct has_explicit_copy_constructor : std::false_type {};
+
+template <typename T>
+struct has_explicit_copy_constructor<
+    T, typename std::enable_if<std::is_copy_constructible_v<T> && !std::is_convertible_v<const T&, T>>::type>
+    : std::true_type {};
+
 /**
  * @brief The Fragment concept.
  * @details This concept can be used as a template type constraint
@@ -39,12 +48,12 @@ namespace psyqo {
 
 template <typename Frag>
 concept Fragment = requires(Frag frag) {
-    {(alignof(Frag) & 3) == 0};
-    {(sizeof(Frag) & 3) == 0};
-    {(sizeof(frag.head)) == 4};
-    {((offsetof(Frag, head)) & 3) == 0};
-    { frag.getActualFragmentSize() }
-    ->std::convertible_to<size_t>;
+    { (alignof(Frag) & 3) == 0 };
+    { (sizeof(Frag) & 3) == 0 };
+    { (sizeof(frag.head)) == 4 };
+    { ((offsetof(Frag, head)) & 3) == 0 };
+    { has_explicit_copy_constructor<Frag>() } -> std::convertible_to<std::true_type>;
+    { frag.getActualFragmentSize() } -> std::convertible_to<size_t>;
 };
 
 }  // namespace psyqo

src/mips/psyqo/fragments.hh

@@ -68,6 +68,7 @@ struct SimpleFragment {
     SimpleFragment() {
         static_assert(sizeof(*this) == (sizeof(uint32_t) + sizeof(Prim)), "Spurious padding in simple fragment");
     }
+    explicit SimpleFragment(const SimpleFragment &) = default;
     typedef Prim FragmentBaseType;
     constexpr size_t getActualFragmentSize() const { return sizeof(Prim) / sizeof(uint32_t); }
     uint32_t head;
@@ -92,6 +93,7 @@ struct FixedFragment {
         static_assert(sizeof(*this) == (sizeof(unsigned) + sizeof(uint32_t) + sizeof(Prim) * N),
                       "Spurious padding in fixed fragment");
     }
+    explicit FixedFragment(const FixedFragment &) = default;
     typedef Prim FragmentBaseType;
     size_t getActualFragmentSize() const { return (sizeof(Prim) * count) / sizeof(uint32_t); }
     unsigned count = N;
@@ -120,6 +122,7 @@ struct FixedFragmentWithPrologue {
         static_assert(sizeof(*this) == (sizeof(unsigned) + sizeof(uint32_t) + sizeof(P) + sizeof(Prim) * N),
                       "Spurious padding in fixed fragment");
     }
+    explicit FixedFragmentWithPrologue(const FixedFragmentWithPrologue &) = default;
     typedef Prim FragmentBaseType;
     size_t getActualFragmentSize() const { return (sizeof(P) + sizeof(Prim) * count) / sizeof(uint32_t); }
     unsigned count = N;