From cee530733ea43e480dbe782f2fb1358257710750 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Fri, 22 Mar 2019 00:13:39 +0100
Subject: [PATCH] Math: make it possible to opt out of Debug output operators.

Undocumented at this point, will be used for magnum-singles export.
---
 src/Magnum/Math/Angle.h             | 4 ++++
 src/Magnum/Math/Bezier.h            | 2 ++
 src/Magnum/Math/BoolVector.h        | 4 ++++
 src/Magnum/Math/Color.h             | 2 ++
 src/Magnum/Math/Complex.h           | 4 ++++
 src/Magnum/Math/CubicHermite.h      | 2 ++
 src/Magnum/Math/Dual.h              | 5 +++++
 src/Magnum/Math/DualComplex.h       | 2 ++
 src/Magnum/Math/DualQuaternion.h    | 2 ++
 src/Magnum/Math/Frustum.h           | 4 ++++
 src/Magnum/Math/Half.h              | 2 ++
 src/Magnum/Math/Quaternion.h        | 4 ++++
 src/Magnum/Math/Range.h             | 2 ++
 src/Magnum/Math/RectangularMatrix.h | 4 ++++
 src/Magnum/Math/Vector.h            | 4 ++++
 15 files changed, 47 insertions(+)

diff --git a/src/Magnum/Math/Angle.h b/src/Magnum/Math/Angle.h
index 91d3ebca1..59f5d91fa 100644
--- a/src/Magnum/Math/Angle.h
+++ b/src/Magnum/Math/Angle.h
@@ -29,7 +29,9 @@
  * @brief Class @ref Magnum::Math::Deg, @ref Magnum::Math::Rad, literal @link Magnum::Math::Literals::operator""_degf() @endlink, @link Magnum::Math::Literals::operator""_radf() @endlink, @link Magnum::Math::Literals::operator""_deg() @endlink, @link Magnum::Math::Literals::operator""_rad() @endlink
  */
 
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/visibility.h"
 #include "Magnum/Math/Constants.h"
@@ -229,6 +231,7 @@ constexpr Rad<Float> operator "" _radf(long double value) { return Rad<Float>(Fl
 template<class T> constexpr Deg<T>::Deg(Unit<Rad, T> value): Unit<Math::Deg, T>(T(180)*T(value)/Math::Constants<T>::pi()) {}
 template<class T> constexpr Rad<T>::Rad(Unit<Deg, T> value): Unit<Math::Rad, T>(T(value)*Math::Constants<T>::pi()/T(180)) {}
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Rad} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Unit<Rad, T>& value) {
     return debug << "Rad(" << Corrade::Utility::Debug::nospace << T(value) << Corrade::Utility::Debug::nospace << ")";
@@ -246,6 +249,7 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Unit<Rad, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Unit<Deg, Double>&);
 #endif
+#endif
 
 }}
 
diff --git a/src/Magnum/Math/Bezier.h b/src/Magnum/Math/Bezier.h
index 2bc4b6a8a..ad8d00327 100644
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@@ -293,6 +293,7 @@ Convenience alternative to @cpp CubicBezier<3, T> @ce. See @ref CubicBezier and
 template<class T> using CubicBezier3D = CubicBezier<3, T>;
 #endif
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Bezier} */
 template<UnsignedInt order, UnsignedInt dimensions, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Bezier<order, dimensions, T>& value) {
     debug << "Bezier(" << Corrade::Utility::Debug::nospace;
@@ -316,6 +317,7 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Bezier<3, 2, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Bezier<3, 3, Double>&);
 #endif
+#endif
 
 namespace Implementation {
 
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index f597fa2b2..11e1d1451 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -29,7 +29,9 @@
  * @brief Class @ref Magnum::Math::BoolVector
  */
 
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/Types.h"
 #include "Magnum/Math/Math.h"
@@ -291,6 +293,7 @@ template<std::size_t size> class BoolVector {
         UnsignedByte _data[(size-1)/8+1];
 };
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{BoolVector} */
 template<std::size_t size> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const BoolVector<size>& value) {
     debug << "BoolVector(" << Corrade::Utility::Debug::nospace;
@@ -300,6 +303,7 @@ template<std::size_t size> Corrade::Utility::Debug& operator<<(Corrade::Utility:
     }
     return debug << Corrade::Utility::Debug::nospace << ")";
 }
+#endif
 
 template<std::size_t size> inline bool BoolVector<size>::operator==(const BoolVector<size>& other) const {
     for(std::size_t i = 0; i != size/8; ++i)
diff --git a/src/Magnum/Math/Color.h b/src/Magnum/Math/Color.h
index c6fef33c8..ea1b355a2 100644
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@@ -1191,6 +1191,7 @@ inline Color4<Float> operator "" _srgbaf(unsigned long long value) {
 
 }
 
+#ifndef CORRADE_NO_DEBUG
 /**
 @debugoperator{Color3}
 
@@ -1206,6 +1207,7 @@ Prints the value as hex color (e.g. @cb{.shell-session} #9933aaff @ce). Other
 underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const Vector<size, T>&).
 */
 MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Color4<UnsignedByte>& value);
+#endif
 
 namespace Implementation {
     template<class T> struct TypeForSize<3, Color3<T>> { typedef Color3<T> Type; };
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index ce3fff2ac..62a7469cd 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -30,7 +30,9 @@
  */
 
 #include <Corrade/Utility/Assert.h>
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/Math/Matrix.h"
 #include "Magnum/Math/Vector2.h"
@@ -607,6 +609,7 @@ template<class T> inline Complex<T> slerp(const Complex<T>& normalizedA, const C
     return (std::sin((T(1) - t)*a)*normalizedA + std::sin(t*a)*normalizedB)/std::sin(a);
 }
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Complex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Complex<T>& value) {
     return debug << "Complex(" << Corrade::Utility::Debug::nospace
@@ -619,6 +622,7 @@ template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& d
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Complex<Float>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Complex<Double>&);
 #endif
+#endif
 
 namespace Implementation {
 
diff --git a/src/Magnum/Math/CubicHermite.h b/src/Magnum/Math/CubicHermite.h
index efbf7df8c..b76eadb4a 100644
--- a/src/Magnum/Math/CubicHermite.h
+++ b/src/Magnum/Math/CubicHermite.h
@@ -260,6 +260,7 @@ Convenience alternative to @cpp CubicHermite<Quaternion<T>> @ce. See
 template<class T> using CubicHermiteQuaternion = CubicHermite<Quaternion<T>>;
 #endif
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{CubicHermite} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const CubicHermite<T>& value) {
     return debug << "CubicHermite(" << Corrade::Utility::Debug::nospace
@@ -283,6 +284,7 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const CubicHermite<Quaternion<Float>>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const CubicHermite<Quaternion<Double>>&);
 #endif
+#endif
 
 /** @relatesalso CubicHermite
 @brief Constant interpolation of two cubic Hermite spline points
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index ac06f6766..b2e39b28f 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -30,7 +30,10 @@
  */
 
 #include <cmath>
+#include <Corrade/Utility/TypeTraits.h>
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/Math/Angle.h"
 #include "Magnum/Math/Tags.h"
@@ -345,12 +348,14 @@ template<class T, class U, class V = typename std::enable_if<!Implementation::Is
     }
 #endif
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Dual} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Dual<T>& value) {
     return debug << "Dual(" << Corrade::Utility::Debug::nospace
         << value.real() << Corrade::Utility::Debug::nospace << ","
         << value.dual() << Corrade::Utility::Debug::nospace << ")";
 }
+#endif
 
 /** @relatesalso Dual
 @brief Square root of dual number
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index edb4b7299..4c0fc3a74 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -369,6 +369,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualComplex, Vector2, T)
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{DualComplex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualComplex<T>& value) {
     return debug << "DualComplex({" << Corrade::Utility::Debug::nospace
@@ -384,6 +385,7 @@ template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& d
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const DualComplex<Float>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const DualComplex<Double>&);
 #endif
+#endif
 
 namespace Implementation {
     template<class T> struct StrictWeakOrdering<DualComplex<T>>: StrictWeakOrdering<Dual<Complex<T>>> {};
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index 437a5f692..2162399df 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -525,6 +525,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualQuaternion, Quaternion, T)
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{DualQuaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualQuaternion<T>& value) {
     return debug << "DualQuaternion({{" << Corrade::Utility::Debug::nospace
@@ -544,6 +545,7 @@ template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& d
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const DualQuaternion<Float>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const DualQuaternion<Double>&);
 #endif
+#endif
 
 namespace Implementation {
     template<class T> struct StrictWeakOrdering<DualQuaternion<T>>: StrictWeakOrdering<Dual<Quaternion<T>>> {};
diff --git a/src/Magnum/Math/Frustum.h b/src/Magnum/Math/Frustum.h
index fb16c2ef9..cd300b5d6 100644
--- a/src/Magnum/Math/Frustum.h
+++ b/src/Magnum/Math/Frustum.h
@@ -32,7 +32,9 @@
 
 #include <Corrade/configure.h>
 #include <Corrade/Containers/ArrayView.h>
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/Math/Matrix4.h"
 #include "Magnum/Math/Vector4.h"
@@ -146,6 +148,7 @@ template<class T> class Frustum {
         Vector4<T> _data[6];
 };
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Frustum} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Frustum<T>& value) {
     debug << "Frustum({" << Corrade::Utility::Debug::nospace;
@@ -164,6 +167,7 @@ template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& d
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Frustum<Float>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Frustum<Float>&);
 #endif
+#endif
 
 template<class T> constexpr Frustum<T>::Frustum(IdentityInitT) noexcept: _data{
     { 1.0f,  0.0f,  0.0f, 1.0f},
diff --git a/src/Magnum/Math/Half.h b/src/Magnum/Math/Half.h
index 15ba7962e..99f128fb5 100644
--- a/src/Magnum/Math/Half.h
+++ b/src/Magnum/Math/Half.h
@@ -150,6 +150,7 @@ inline Half operator "" _h(long double value) { return Half(Float(value)); }
 
 }
 
+#ifndef CORRADE_NO_DEBUG
 /**
 @debugoperator{Half}
 
@@ -160,6 +161,7 @@ Prints the value with 4 significant digits.
 @todoc remove `long double value` once doxygen can link to long double overloads properly
 */
 MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, Half value);
+#endif
 
 namespace Implementation {
 
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index d49dbd089..074cb5fa4 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -31,7 +31,9 @@
 
 #include <cmath>
 #include <Corrade/Utility/Assert.h>
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/Math/Matrix.h"
 #include "Magnum/Math/TypeTraits.h"
@@ -630,6 +632,7 @@ template<class T> inline Quaternion<T> operator/(T scalar, const Quaternion<T>&
     return {scalar/quaternion.vector(), scalar/quaternion.scalar()};
 }
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Quaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Quaternion<T>& value) {
     return debug << "Quaternion({" << Corrade::Utility::Debug::nospace
@@ -644,6 +647,7 @@ template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& d
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Quaternion<Float>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Quaternion<Double>&);
 #endif
+#endif
 
 namespace Implementation {
 
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 317e4ea49..0509260e0 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -724,6 +724,7 @@ template<UnsignedInt dimensions, class T> inline bool intersects(const Range<dim
            (Vector<dimensions, T>{a.min()} < b.max()).all();
 }
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Range} */
 template<UnsignedInt dimensions, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Range<dimensions, T>& value) {
     debug << "Range({" << Corrade::Utility::Debug::nospace << Vector<dimensions, T>{value.min()}[0];
@@ -748,6 +749,7 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Range<2, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Range<3, Double>&);
 #endif
+#endif
 
 template<UnsignedInt dimensions, class T> inline bool Range<dimensions, T>::operator==(const Range<dimensions, T>& other) const {
     /* For non-scalar types default implementation of TypeTraits would be used,
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index cb15e2ac1..c8882f64b 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -581,6 +581,7 @@ template<std::size_t size, std::size_t cols, class T> inline RectangularMatrix<c
     return RectangularMatrix<1, size, T>(vector)*matrix;
 }
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{RectangularMatrix} */
 template<std::size_t cols, std::size_t rows, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Magnum::Math::RectangularMatrix<cols, rows, T>& value) {
     debug << "Matrix(" << Corrade::Utility::Debug::nospace;
@@ -617,7 +618,10 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const RectangularMatrix<4, 2, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const RectangularMatrix<3, 4, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const RectangularMatrix<4, 3, Double>&);
+#endif
+#endif
 
+#ifndef DOXYGEN_GENERATING_OUTPUT
 #define MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(cols, rows, ...)   \
     static __VA_ARGS__& from(T* data) {                                     \
         return *reinterpret_cast<__VA_ARGS__*>(data);                       \
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 958feef52..b42067d5e 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -34,7 +34,9 @@
 #include <algorithm> /* std::max() */
 #endif
 #include <Corrade/Utility/Assert.h>
+#ifndef CORRADE_NO_DEBUG
 #include <Corrade/Utility/Debug.h>
+#endif
 
 #include "Magnum/visibility.h"
 #include "Magnum/Math/Angle.h"
@@ -1102,6 +1104,7 @@ operator/(const Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b)
     return copy /= b;
 }
 
+#ifndef CORRADE_NO_DEBUG
 /** @debugoperator{Vector} */
 template<std::size_t size, class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Vector<size, T>& value) {
     debug << "Vector(" << Corrade::Utility::Debug::nospace;
@@ -1127,6 +1130,7 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Vector<3, Double>&);
 extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug&, const Vector<4, Double>&);
 #endif
+#endif
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #define MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(size, Type)                   \