From 105cef5efdb8cb34cb2cd5b94884b06fae86edbd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Wed, 28 Mar 2018 22:53:34 +0200
Subject: [PATCH] No need to use fully qualified name for \debugoperator.

---
 src/Magnum/Array.h                  | 8 ++++----
 src/Magnum/Audio/Buffer.h           | 2 +-
 src/Magnum/Audio/Context.h          | 2 +-
 src/Magnum/Audio/Renderer.h         | 4 ++--
 src/Magnum/Audio/Source.h           | 2 +-
 src/Magnum/Math/Angle.h             | 4 ++--
 src/Magnum/Math/Bezier.h            | 2 +-
 src/Magnum/Math/BoolVector.h        | 2 +-
 src/Magnum/Math/Color.h             | 4 ++--
 src/Magnum/Math/Complex.h           | 2 +-
 src/Magnum/Math/Dual.h              | 2 +-
 src/Magnum/Math/DualComplex.h       | 2 +-
 src/Magnum/Math/DualQuaternion.h    | 2 +-
 src/Magnum/Math/Frustum.h           | 2 +-
 src/Magnum/Math/Half.h              | 2 +-
 src/Magnum/Math/Quaternion.h        | 2 +-
 src/Magnum/Math/Range.h             | 2 +-
 src/Magnum/Math/RectangularMatrix.h | 2 +-
 src/Magnum/Math/Vector.h            | 2 +-
 src/Magnum/Resource.h               | 4 ++--
 src/Magnum/SceneGraph/Animable.h    | 2 +-
 src/Magnum/Shapes/Composition.h     | 2 +-
 22 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/Magnum/Array.h b/src/Magnum/Array.h
index 62b3e111d..f6edc34ec 100644
--- a/src/Magnum/Array.h
+++ b/src/Magnum/Array.h
@@ -199,7 +199,7 @@ template<class T> class Array3D: public Array<3, T> {
         constexpr Array2D<T> xy() const { return {(*this)[0], (*this)[1]}; } /**< @overload */
 };
 
-/** @debugoperator{Magnum::Array} */
+/** @debugoperator{Array} */
 template<UnsignedInt dimensions, class T> Debug& operator<<(Debug& debug, const Array<dimensions, T>& value) {
     debug << "Array(" << Corrade::Utility::Debug::nospace;
     for(UnsignedInt i = 0; i != dimensions; ++i) {
@@ -209,17 +209,17 @@ template<UnsignedInt dimensions, class T> Debug& operator<<(Debug& debug, const
     return debug << Corrade::Utility::Debug::nospace << ")";
 }
 
-/** @debugoperator{Magnum::Array1D} */
+/** @debugoperator{Array1D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array1D<T>& value) {
     return debug << static_cast<const Array<1, T>&>(value);
 }
 
-/** @debugoperator{Magnum::Array2D} */
+/** @debugoperator{Array2D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array2D<T>& value) {
     return debug << static_cast<const Array<2, T>&>(value);
 }
 
-/** @debugoperator{Magnum::Array3D} */
+/** @debugoperator{Array3D} */
 template<class T> inline Debug& operator<<(Debug& debug, const Array3D<T>& value) {
     return debug << static_cast<const Array<3, T>&>(value);
 }
diff --git a/src/Magnum/Audio/Buffer.h b/src/Magnum/Audio/Buffer.h
index 98a345281..61e923418 100644
--- a/src/Magnum/Audio/Buffer.h
+++ b/src/Magnum/Audio/Buffer.h
@@ -246,7 +246,7 @@ class Buffer {
         ALuint _id;
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Buffer,Magnum::Audio::Buffer::Format} */
+/** @debugoperatorclassenum{Buffer,Buffer::Format} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Buffer::Format value);
 
 inline Buffer::Buffer(Buffer&& other): _id(other._id) {
diff --git a/src/Magnum/Audio/Context.h b/src/Magnum/Audio/Context.h
index 9190e3e3e..ca877d0a2 100644
--- a/src/Magnum/Audio/Context.h
+++ b/src/Magnum/Audio/Context.h
@@ -476,7 +476,7 @@ MAGNUM_ASSERT_AUDIO_EXTENSION_SUPPORTED(Extensions::ALC::SOFTX::HRTF);
     } while(0)
 #endif
 
-/** @debugoperatorclassenum{Magnum::Audio::Context,Magnum::Audio::Context::HrtfStatus} */
+/** @debugoperatorclassenum{Context,Context::HrtfStatus} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Context::HrtfStatus value);
 
 }}
diff --git a/src/Magnum/Audio/Renderer.h b/src/Magnum/Audio/Renderer.h
index 3150bbda0..f0edbb4f5 100644
--- a/src/Magnum/Audio/Renderer.h
+++ b/src/Magnum/Audio/Renderer.h
@@ -268,10 +268,10 @@ class Renderer {
         /*@}*/
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Renderer,Magnum::Audio::Renderer::Error} */
+/** @debugoperatorclassenum{Renderer,Renderer::Error} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Renderer::Error value);
 
-/** @debugoperatorclassenum{Magnum::Audio::Renderer,Magnum::Audio::Renderer::DistanceModel} */
+/** @debugoperatorclassenum{Renderer,Renderer::DistanceModel} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Renderer::DistanceModel value);
 
 }}
diff --git a/src/Magnum/Audio/Source.h b/src/Magnum/Audio/Source.h
index 07f344a43..c4bae6dbe 100644
--- a/src/Magnum/Audio/Source.h
+++ b/src/Magnum/Audio/Source.h
@@ -705,7 +705,7 @@ class MAGNUM_AUDIO_EXPORT Source {
         ALuint _id;
 };
 
-/** @debugoperatorclassenum{Magnum::Audio::Source,Magnum::Audio::Source::State} */
+/** @debugoperatorclassenum{Source,Source::State} */
 MAGNUM_AUDIO_EXPORT Debug& operator<<(Debug& debug, Source::State value);
 
 inline Source::Source(Source&& other): _id(other._id) {
diff --git a/src/Magnum/Math/Angle.h b/src/Magnum/Math/Angle.h
index 156a63718..c02449728 100644
--- a/src/Magnum/Math/Angle.h
+++ b/src/Magnum/Math/Angle.h
@@ -267,12 +267,12 @@ 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)) {}
 
-/** @debugoperator{Magnum::Math::Rad} */
+/** @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 << ")";
 }
 
-/** @debugoperator{Magnum::Math::Deg} */
+/** @debugoperator{Deg} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Unit<Deg, T>& value) {
     return debug << "Deg(" << Corrade::Utility::Debug::nospace << T(value) << Corrade::Utility::Debug::nospace << ")";
 }
diff --git a/src/Magnum/Math/Bezier.h b/src/Magnum/Math/Bezier.h
index 0a443ebc2..531b3b880 100644
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@@ -249,7 +249,7 @@ Convenience alternative to @cpp CubicBezier<3, T> @ce. See @ref CubicBezier and
 template<class T> using CubicBezier3D = CubicBezier<3, T>;
 #endif
 
-/** @debugoperator{Magnum::Math::Bezier} */
+/** @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;
     for(UnsignedInt o = 0; o != order + 1; ++o) {
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 50b672937..79a94563b 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -235,7 +235,7 @@ template<std::size_t size> class BoolVector {
         UnsignedByte _data[(size-1)/8+1];
 };
 
-/** @debugoperator{Magnum::Math::BoolVector} */
+/** @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;
     for(std::size_t i = 0; i != size; ++i) {
diff --git a/src/Magnum/Math/Color.h b/src/Magnum/Math/Color.h
index e98367070..60d716186 100644
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@@ -1179,7 +1179,7 @@ inline Color4<Float> operator "" _srgbaf(unsigned long long value) {
 }
 
 /**
-@debugoperator{Magnum::Math::Color3}
+@debugoperator{Color3}
 
 Prints the value as hex color (e.g. @cb{.shell-session} #ff33aa @ce). Other
 underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const Vector<size, T>&).
@@ -1187,7 +1187,7 @@ underlying types are handled by @ref operator<<(Corrade::Utility::Debug&, const
 MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Color3<UnsignedByte>& value);
 
 /**
-@debugoperator{Magnum::Math::Color4}
+@debugoperator{Color4}
 
 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>&).
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index c3b792149..6841b5946 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -456,7 +456,7 @@ template<class T> inline Complex<T> operator/(T scalar, const Complex<T>& comple
     return {scalar/complex.real(), scalar/complex.imaginary()};
 }
 
-/** @debugoperator{Magnum::Math::Complex} */
+/** @debugoperator{Complex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Complex<T>& value) {
     return debug << "Complex(" << Corrade::Utility::Debug::nospace
         << value.real() << Corrade::Utility::Debug::nospace << ","
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index bba27807a..5cf8c04ee 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -323,7 +323,7 @@ template<class T, class U, class V = typename std::enable_if<!Implementation::Is
     }
 #endif
 
-/** @debugoperator{Magnum::Math::Dual} */
+/** @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 << ","
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index 5bb8345ec..2dc3b03ae 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -354,7 +354,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualComplex, Vector2, T)
 
-/** @debugoperator{Magnum::Math::DualQuaternion} */
+/** @debugoperator{DualComplex} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualComplex<T>& value) {
     return debug << "DualComplex({" << Corrade::Utility::Debug::nospace
           << value.real().real() << Corrade::Utility::Debug::nospace << ","
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index 859b5fb96..398d6f168 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -429,7 +429,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
 
 MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualQuaternion, Quaternion, T)
 
-/** @debugoperator{Magnum::Math::DualQuaternion} */
+/** @debugoperator{DualQuaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const DualQuaternion<T>& value) {
     return debug << "DualQuaternion({{" << Corrade::Utility::Debug::nospace
         << value.real().vector().x() << Corrade::Utility::Debug::nospace << ","
diff --git a/src/Magnum/Math/Frustum.h b/src/Magnum/Math/Frustum.h
index 53c88d806..0a659850d 100644
--- a/src/Magnum/Math/Frustum.h
+++ b/src/Magnum/Math/Frustum.h
@@ -146,7 +146,7 @@ template<class T> class Frustum {
         Vector4<T> _data[6];
 };
 
-/** @debugoperator{Magnum::Math::Frustum} */
+/** @debugoperator{Frustum} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Frustum<T>& value) {
     debug << "Frustum({" << Corrade::Utility::Debug::nospace;
     for(std::size_t i = 0; i != 6; ++i) {
diff --git a/src/Magnum/Math/Half.h b/src/Magnum/Math/Half.h
index 878f60054..7f3738a8d 100644
--- a/src/Magnum/Math/Half.h
+++ b/src/Magnum/Math/Half.h
@@ -162,7 +162,7 @@ inline Half operator "" _h(long double value) { return Half(Float(value)); }
 
 }
 
-/** @debugoperator{Magnum::Math::Half} */
+/** @debugoperator{Half} */
 inline Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, Half value) {
     return debug << Float(value);
 }
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index 306ac0d5b..82a1a61ca 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -508,7 +508,7 @@ template<class T> inline Quaternion<T> operator/(T scalar, const Quaternion<T>&
     return {scalar/quaternion.vector(), scalar/quaternion.scalar()};
 }
 
-/** @debugoperator{Magnum::Math::Quaternion} */
+/** @debugoperator{Quaternion} */
 template<class T> Corrade::Utility::Debug& operator<<(Corrade::Utility::Debug& debug, const Quaternion<T>& value) {
     return debug << "Quaternion({" << Corrade::Utility::Debug::nospace
         << value.vector().x() << Corrade::Utility::Debug::nospace << ","
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 5699e4e84..66a82bf1b 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -540,7 +540,7 @@ template<UnsignedInt dimensions, class T> inline Range<dimensions, T> join(const
     return {min(a.min(), b.min()), max(a.max(), b.max())};
 }
 
-/** @debugoperator{Magnum::Math::Range} */
+/** @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 << value.min()[0];
     for(UnsignedInt i = 1; i != dimensions; ++i)
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index 4ef2c4f44..adb97c35b 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -588,7 +588,7 @@ template<std::size_t size, std::size_t cols, class T> inline RectangularMatrix<c
     return RectangularMatrix<1, size, T>(vector)*matrix;
 }
 
-/** @debugoperator{Magnum::Math::RectangularMatrix} */
+/** @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;
     for(std::size_t row = 0; row != rows; ++row) {
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 3527390f0..f810ef717 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -1075,7 +1075,7 @@ operator/(const Vector<size, Integral>& a, const Vector<size, FloatingPoint>& b)
     return copy /= b;
 }
 
-/** @debugoperator{Magnum::Math::Vector} */
+/** @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;
     for(std::size_t i = 0; i != size; ++i) {
diff --git a/src/Magnum/Resource.h b/src/Magnum/Resource.h
index 7806baabe..c569e13ac 100644
--- a/src/Magnum/Resource.h
+++ b/src/Magnum/Resource.h
@@ -68,7 +68,7 @@ enum class ResourceState: UnsignedByte {
     Final
 };
 
-/** @debugoperatorenum{Magnum::ResourceState} */
+/** @debugoperatorenum{ResourceState} */
 MAGNUM_EXPORT Debug& operator<<(Debug& debug, ResourceState value);
 
 /**
@@ -99,7 +99,7 @@ class ResourceKey: public Utility::MurmurHash2::Digest {
         template<std::size_t size> constexpr ResourceKey(const char(&key)[size]): Utility::MurmurHash2::Digest(Utility::MurmurHash2()(key)) {}
 };
 
-/** @debugoperator{Magnum::ResourceKey} */
+/** @debugoperator{ResourceKey} */
 inline Debug& operator<<(Debug& debug, const ResourceKey& value) {
     return debug << static_cast<const Utility::HashDigest<sizeof(std::size_t)>&>(value);
 }
diff --git a/src/Magnum/SceneGraph/Animable.h b/src/Magnum/SceneGraph/Animable.h
index f43e67338..85d5ff8b8 100644
--- a/src/Magnum/SceneGraph/Animable.h
+++ b/src/Magnum/SceneGraph/Animable.h
@@ -56,7 +56,7 @@ enum class AnimationState: UnsignedByte {
     Running
 };
 
-/** @debugoperatorenum{Magnum::SceneGraph::AnimationState} */
+/** @debugoperatorenum{AnimationState} */
 MAGNUM_SCENEGRAPH_EXPORT Debug& operator<<(Debug& debug, AnimationState value);
 
 /**
diff --git a/src/Magnum/Shapes/Composition.h b/src/Magnum/Shapes/Composition.h
index 896beb965..c0fb87303 100644
--- a/src/Magnum/Shapes/Composition.h
+++ b/src/Magnum/Shapes/Composition.h
@@ -194,7 +194,7 @@ typedef Composition<2> Composition2D;
 typedef Composition<3> Composition3D;
 
 #ifdef DOXYGEN_GENERATING_OUTPUT
-/** @debugoperatorclassenum{Magnum::Shapes::Composition,Magnum::Shapes::Composition::Type} */
+/** @debugoperatorclassenum{Composition,Composition::Type} */
 template<UnsignedInt dimensions> Debug& operator<<(Debug& debug, typename Composition<dimensions>::Type value);
 #endif