Deleted constructors of classes with only static members.

They shouldn't be instantiated, prevent mistakes with this.

src/DebugMarker.h

@@ -41,6 +41,8 @@ class MAGNUM_EXPORT DebugMarker {
     friend class Context;
 
     public:
+        DebugMarker() = delete;
+
         /** @brief Put string mark into OpenGL command stream */
         inline static void mark(const std::string& string) {
             markImplementation(string);

src/DimensionTraits.h

@@ -37,6 +37,8 @@ namespace Math {
 
 /** @brief Matrix, point and vector specializations for given dimension count */
 template<std::uint8_t dimensions, class T = GLfloat> struct DimensionTraits {
+    DimensionTraits() = delete;
+
     #ifdef DOXYGEN_GENERATING_OUTPUT
     /**
      * @brief Vector type
@@ -66,21 +68,29 @@ template<std::uint8_t dimensions, class T = GLfloat> struct DimensionTraits {
 #ifndef DOXYGEN_GENERATING_OUTPUT
 /* One dimension */
 template<class T> struct DimensionTraits<1, T> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector<1, T> VectorType;
 };
 
 /* Two dimensions - integral */
 template<class T> struct DimensionTraits<2, T> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector2<T> VectorType;
 };
 
 /* Two dimensions - floating-point */
 template<> struct DimensionTraits<2, float> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector2<float> VectorType;
     typedef Math::Point2D<float> PointType;
     typedef Math::Matrix3<float> MatrixType;
 };
 template<> struct DimensionTraits<2, double> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector2<double> VectorType;
     typedef Math::Point2D<double> PointType;
     typedef Math::Matrix3<double> MatrixType;
@@ -88,16 +98,22 @@ template<> struct DimensionTraits<2, double> {
 
 /* Three dimensions - integral */
 template<class T> struct DimensionTraits<3, T> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector3<T> VectorType;
 };
 
 /* Three dimensions - floating-point */
 template<> struct DimensionTraits<3, float> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector3<float> VectorType;
     typedef Math::Point3D<float> PointType;
     typedef Math::Matrix4<float> MatrixType;
 };
 template<> struct DimensionTraits<3, double> {
+    DimensionTraits() = delete;
+
     typedef Math::Vector3<double> VectorType;
     typedef Math::Point3D<double> PointType;
     typedef Math::Matrix4<double> MatrixType;

src/Math/Algorithms/GaussJordan.h

@@ -31,6 +31,8 @@ http://elonen.iki.fi/code/misc-notes/python-gaussj/index.html.
 */
 class GaussJordan {
     public:
+        GaussJordan() = delete;
+
         /**
          * @brief Eliminate transposed matrices in place
          * @param a     Transposed left side of augmented matrix

src/Math/Constants.h

@@ -27,6 +27,8 @@ namespace Magnum { namespace Math {
 @see Magnum::Constants
 */
 template<class T> struct Constants {
+    Constants() = delete;
+
     /* See MathTypeTraits for answer why these are functions and not constants. */
     #ifdef DOXYGEN_GENERATING_OUTPUT
     /**
@@ -43,11 +45,15 @@ template<class T> struct Constants {
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template<> struct Constants<double> {
+    Constants() = delete;
+
     static inline constexpr double pi()    { return 3.141592653589793; }
     static inline constexpr double sqrt2() { return 1.414213562373095; }
     static inline constexpr double sqrt3() { return 1.732050807568877; }
 };
 template<> struct Constants<float> {
+    Constants() = delete;
+
     static inline constexpr float pi()    { return 3.141592654f; }
     static inline constexpr float sqrt2() { return 1.414213562f; }
     static inline constexpr float sqrt3() { return 1.732050808f; }

src/Math/Geometry/Distance.h

@@ -28,6 +28,8 @@ namespace Magnum { namespace Math { namespace Geometry {
 /** @brief Functions for computing distances */
 class Distance {
     public:
+        Distance() = delete;
+
         /**
          * @brief %Distance of line and point in 2D
          * @param a         First point of the line

src/Math/Geometry/Intersection.h

@@ -26,6 +26,8 @@ namespace Magnum { namespace Math { namespace Geometry {
 /** @brief Functions for computing intersections */
 class Intersection {
     public:
+        Intersection() = delete;
+
         /**
          * @brief %Intersection of a plane and line
          * @param planePosition Plane position

src/Math/MathTypeTraits.h

@@ -46,6 +46,8 @@ sense, it has empty implementation for unknown types or types which don't
 support given feature, thus forcing the compilation stop with an error.
 */
 template<class T> struct MathTypeTraits {
+    MathTypeTraits() = delete;
+
     /*
      * The following values are implemented as inline functions, not as
      * static const variables, because the compiler will inline the return
@@ -101,6 +103,8 @@ template<class T> struct MathTypeTraits {
 namespace Implementation {
 
 template<class T> struct MathTypeTraitsIntegral {
+    MathTypeTraitsIntegral() = delete;
+
     inline constexpr static T epsilon() { return 1; }
 
     inline constexpr static bool equals(T a, T b) {
@@ -109,6 +113,8 @@ template<class T> struct MathTypeTraitsIntegral {
 };
 
 template<class T> struct MathTypeTraitsFloatingPoint {
+    MathTypeTraitsFloatingPoint() = delete;
+
     inline static bool equals(T a, T b) {
         return std::abs(a - b) < MathTypeTraits<T>::epsilon();
     }

src/Math/RectangularMatrix.h

@@ -517,6 +517,8 @@ namespace Corrade { namespace Utility {
 
 /** @configurationvalue{Magnum::Math::RectangularMatrix} */
 template<std::size_t cols, std::size_t rows, class T> struct ConfigurationValue<Magnum::Math::RectangularMatrix<cols, rows, T>> {
+    ConfigurationValue() = delete;
+
     /** @brief Writes elements separated with spaces */
     static std::string toString(const Magnum::Math::RectangularMatrix<cols, rows, T>& value, ConfigurationValueFlags flags) {
         std::string output;

src/Mesh.h

@@ -754,6 +754,8 @@ namespace Corrade { namespace Utility {
 
 /** @configurationvalue{Magnum::Mesh} */
 template<> struct MAGNUM_EXPORT ConfigurationValue<Magnum::Mesh::Primitive> {
+    ConfigurationValue() = delete;
+
     /**
      * @brief Writes enum value as string
      *

src/Platform/ExtensionWrangler.h

@@ -24,6 +24,8 @@ namespace Magnum { namespace Platform {
 /** @brief %Extension wrangler interface */
 class ExtensionWrangler {
     public:
+        ExtensionWrangler() = delete;
+
         /** @brief Whether to enable or disable experimental features */
         enum class ExperimentalFeatures {
             Disable,

src/Renderer.h

@@ -36,9 +36,9 @@ Access to global renderer configuration.
 @todo @extension{ARB,viewport_array}
 */
 class MAGNUM_EXPORT Renderer {
-    Renderer() = delete;
-
     public:
+        Renderer() = delete;
+
         /**
          * @brief Affected polygon facing for culling, stencil operations and masks
          *

src/SizeTraits.h

@@ -51,20 +51,26 @@ template<std::size_t byte> struct SizeTraits {
     typedef T SizeType;
 };
 #else
-template<std::size_t byte> struct SizeTraits: public SizeTraits<byte - 1> {};
+template<std::size_t byte> struct SizeTraits: public SizeTraits<byte - 1> {
+    SizeTraits() = delete;
+};
 #endif
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template<> struct SizeTraits<0> {
+    SizeTraits() = delete;
     typedef GLubyte SizeType;
 };
 template<> struct SizeTraits<1> {
+    SizeTraits() = delete;
     typedef GLushort SizeType;
 };
 template<> struct SizeTraits<2> {
+    SizeTraits() = delete;
     typedef GLuint SizeType;
 };
 template<> struct SizeTraits<4> {
+    SizeTraits() = delete;
     /* We don't have size type to store 2^32 values */
 };
 #endif
@@ -146,6 +152,8 @@ Useful mainly for computing template parameter value, e.g. in conjunction with
 SizeTraits class.
 */
 template<std::uint32_t base, std::uint32_t exponent> struct Pow {
+    Pow() = delete;
+
     /** @brief Value of the power */
     enum: std::uint32_t {
         #ifndef DOXYGEN_GENERATING_OUTPUT
@@ -158,6 +166,8 @@ template<std::uint32_t base, std::uint32_t exponent> struct Pow {
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template<std::uint32_t base> struct Pow<base, 0> {
+    Pow() = delete;
+
     enum: std::uint32_t { value = 1 };
 };
 #endif
@@ -171,6 +181,8 @@ Useful mainly for computing template parameter value, e.g. in conjunction with
 SizeTraits class.
 */
 template<std::uint32_t base, std::uint32_t number> struct Log {
+    Log() = delete;
+
     /** @brief Value of the logarithm */
     enum: std::uint32_t {
         #ifndef DOXYGEN_GENERATING_OUTPUT
@@ -182,10 +194,11 @@ template<std::uint32_t base, std::uint32_t number> struct Log {
 };
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<std::uint32_t base> struct Log<base, 1>: public Log<base, 0> {};
 template<std::uint32_t base> struct Log<base, 0> {
+    Log() = delete;
     enum: std::uint32_t { value = 0 };
 };
+template<std::uint32_t base> struct Log<base, 1>: public Log<base, 0> {};
 #endif
 
 }

src/TypeTraits.h

@@ -86,7 +86,9 @@ template<class T> struct TypeTraits: Math::MathTypeTraits<T> {
     inline constexpr static std::size_t count();
 };
 #else
-template<class T> struct TypeTraits {};
+template<class T> struct TypeTraits {
+    TypeTraits() = delete;
+};
 #endif
 
 /** @brief OpenGL plain types */
@@ -124,6 +126,8 @@ type = TypeTraits<GLubyte>::imageType();
 @endcode
 */
 template<Type T> class TypeOf {
+    TypeOf() = delete;
+
     #ifdef DOXYGEN_GENERATING_OUTPUT
     typedef U Type; /**< @brief Type */
     #endif
@@ -137,6 +141,8 @@ time, this class alows to get some information also at runtime with tiny
 performance loss.
 */
 struct MAGNUM_EXPORT TypeInfo {
+    TypeInfo() = delete;
+
     /**
      * @brief Size of given type
      *
@@ -160,15 +166,39 @@ struct MAGNUM_EXPORT TypeInfo {
 /** @todo Using Vector3 for textures? */
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<> struct TypeOf<Type::UnsignedByte> { typedef GLubyte Type; };
+template<> struct TypeOf<Type::UnsignedByte> {
-template<> struct TypeOf<Type::Byte> { typedef GLbyte Type; };
+    TypeOf() = delete;
-template<> struct TypeOf<Type::UnsignedShort> { typedef GLushort Type; };
+    typedef GLubyte Type;
-template<> struct TypeOf<Type::Short> { typedef GLshort Type; };
+};
-template<> struct TypeOf<Type::UnsignedInt> { typedef GLuint Type; };
+template<> struct TypeOf<Type::Byte> {
-template<> struct TypeOf<Type::Int> { typedef GLint Type; };
+    TypeOf() = delete;
-template<> struct TypeOf<Type::Float> { typedef GLfloat Type; };
+    typedef GLbyte Type;
+};
+template<> struct TypeOf<Type::UnsignedShort> {
+    TypeOf() = delete;
+    typedef GLushort Type;
+};
+template<> struct TypeOf<Type::Short> {
+    TypeOf() = delete;
+    typedef GLshort Type;
+};
+template<> struct TypeOf<Type::UnsignedInt> {
+    TypeOf() = delete;
+    typedef GLuint Type;
+};
+template<> struct TypeOf<Type::Int> {
+    TypeOf() = delete;
+    typedef GLint Type;
+};
+template<> struct TypeOf<Type::Float> {
+    TypeOf() = delete;
+    typedef GLfloat Type;
+};
 #ifndef MAGNUM_TARGET_GLES
-template<> struct TypeOf<Type::Double> { typedef GLdouble Type; };
+template<> struct TypeOf<Type::Double> {
+    TypeOf() = delete;
+    typedef GLdouble Type;
+};
 #endif
 
 template<> struct TypeTraits<GLubyte>: Math::MathTypeTraits<std::uint8_t> {
@@ -239,6 +269,8 @@ template<> struct TypeTraits<GLdouble>: Math::MathTypeTraits<double> {
 
 namespace Implementation {
     template<std::size_t vectorSize, class T> struct VectorTypeTraits {
+        VectorTypeTraits() = delete;
+
         /* Might be used for attributes, see below */
         inline constexpr static Type type() { return TypeTraits<T>::type(); }
         /* Might be used for attributes, see below */
@@ -286,6 +318,8 @@ template<class T> struct TypeTraits<Color4<T>>: TypeTraits<Math::Vector<4, T>> {
 
 namespace Implementation {
     template<std::size_t cols, std::size_t rows, class T> struct MatrixTypeTraits {
+        MatrixTypeTraits() = delete;
+
         inline constexpr static Type type() { return TypeTraits<T>::type(); }
         /* Might be used for attributes, see below */
         /* Can not be used for indices */
@@ -332,6 +366,8 @@ namespace Corrade { namespace Utility {
 
 /** @configurationvalue{Magnum::TypeInfo} */
 template<> struct MAGNUM_EXPORT ConfigurationValue<Magnum::Type> {
+    ConfigurationValue() = delete;
+
     /**
      * @brief Writes enum value as string
      *