From 742c74e07eee9701727419ce0ea5372c1c877f83 Mon Sep 17 00:00:00 2001
From: lisyarus <lisyarus@gmail.com>
Date: Sat, 6 Aug 2022 19:15:39 +0300
Subject: [PATCH] Revert defaulted three-way comparison: ubuntu 22.04 doesn't
 have mingw-11 yet

---
 libs/geom/include/psemek/geom/matrix.hpp | 51 +++++++++++++++++++++++-
 libs/geom/include/psemek/geom/point.hpp  | 51 +++++++++++++++++++++++-
 libs/geom/include/psemek/geom/vector.hpp | 51 +++++++++++++++++++++++-
 3 files changed, 147 insertions(+), 6 deletions(-)

diff --git a/libs/geom/include/psemek/geom/matrix.hpp b/libs/geom/include/psemek/geom/matrix.hpp
index 87c09ec4..3875e773 100644
--- a/libs/geom/include/psemek/geom/matrix.hpp
+++ b/libs/geom/include/psemek/geom/matrix.hpp
@@ -45,8 +45,6 @@ namespace psemek::geom
 		matrix & operator += (matrix const & v);
 		matrix & operator -= (matrix const & v);
 
-		friend auto operator <=> (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2) = default;
-
 		static matrix zero();
 		static matrix identity();
 		static matrix scalar(T const & s);
@@ -95,6 +93,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t R, std::size_t C>
+	std::strong_ordering operator <=> (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		for (std::size_t i = 0; i < R * C; ++i)
+		{
+			if (m1.coords[i] < m2.coords[i])
+				return std::strong_ordering::less;
+			else if (m1.coords[i] > m2.coords[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator == (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m1 <=> m2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator != (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m1 == m2);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator < (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m1 <=> m2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator > (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m2 < m1);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator <= (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m2 < m1);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator >= (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m1 < m2);
+	}
+
 	template <typename T, std::size_t R, std::size_t C>
 	matrix<T, R, C> operator * (matrix<T, R, C> const & m, T const & s)
 	{
diff --git a/libs/geom/include/psemek/geom/point.hpp b/libs/geom/include/psemek/geom/point.hpp
index 08a7ebc7..747b26c7 100644
--- a/libs/geom/include/psemek/geom/point.hpp
+++ b/libs/geom/include/psemek/geom/point.hpp
@@ -49,8 +49,6 @@ namespace psemek::geom
 		point & operator += (vector<T, N> const & v);
 		point & operator -= (vector<T, N> const & v);
 
-		friend auto operator <=> (point<T, N> const & p1, point<T, N> const & p2) = default;
-
 		static point zero();
 	};
 
@@ -75,6 +73,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t N>
+	bool operator == (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p1 <=> p2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator != (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p1 == p2);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator < (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p1 <=> p2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator > (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p2 < p1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator <= (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p2 < p1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator >= (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p1 < p2);
+	}
+
+	template <typename T, std::size_t N>
+	std::strong_ordering operator <=> (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		for (std::size_t i = 0; i < N; ++i)
+		{
+			if (p1[i] < p2[i])
+				return std::strong_ordering::less;
+			else if (p1[i] > p2[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
 	template <typename T, std::size_t N>
 	point<T, N> operator + (point<T, N> const & p, vector<T, N> const & v)
 	{
diff --git a/libs/geom/include/psemek/geom/vector.hpp b/libs/geom/include/psemek/geom/vector.hpp
index b86bddb9..2c92f7ac 100644
--- a/libs/geom/include/psemek/geom/vector.hpp
+++ b/libs/geom/include/psemek/geom/vector.hpp
@@ -56,8 +56,6 @@ namespace psemek::geom
 		vector & operator += (vector const & v);
 		vector & operator -= (vector const & v);
 
-		friend auto operator <=> (vector<T, N> const & v1, vector<T, N> const & v2) = default;
-
 		static vector zero();
 	};
 
@@ -73,6 +71,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t N>
+	std::strong_ordering operator <=> (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		for (std::size_t i = 0; i < N; ++i)
+		{
+			if (v1[i] < v2[i])
+				return std::strong_ordering::less;
+			else if (v1[i] > v2[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator == (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v1 <=> v2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator != (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator < (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v1 <=> v2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator > (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v2 < v1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator <= (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v2 < v1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator >= (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v1 < v2);
+	}
+
 	template <typename T, std::size_t N>
 	vector<T, N> operator * (vector<T, N> const & v, T const & s)
 	{