Modernize #1

src/Magnum/Context.cpp

@@ -453,14 +453,14 @@ Context::Context(NoCreateT, Int argc, const char** argv, void functionLoader()):
         _disabledExtensions.push_back(extension);
 }
 
-Context::Context(Context&& other): _version{std::move(other._version)},
+Context::Context(Context&& other): _version{other._version},
     #ifndef MAGNUM_TARGET_WEBGL
-    _flags{std::move(other._flags)},
+    _flags{other._flags},
     #endif
-    _extensionRequiredVersion(std::move(other._extensionRequiredVersion)),
+    _extensionRequiredVersion(other._extensionRequiredVersion),
-    _extensionStatus{std::move(other._extensionStatus)},
+    _extensionStatus{other._extensionStatus},
     _supportedExtensions{std::move(other._supportedExtensions)},
-    _state{std::move(other._state)},
+    _state{other._state},
     _detectedDrivers{std::move(other._detectedDrivers)}
 {
     other._state = nullptr;

src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -120,7 +120,7 @@ template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::AbstractShap
         new Shaders::Flat<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
 }
 
-template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}
+template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() = default;
 
 template<UnsignedInt dimensions> void AbstractShapeRenderer<dimensions>::createResources(typename MeshData<dimensions>::Type data) {
     create<dimensions>(data, wireframeMesh, vertexBuffer, indexBuffer);

src/Magnum/DebugTools/ResourceManager.cpp

@@ -48,6 +48,6 @@ ResourceManager::ResourceManager() {
     setFallback(new ShapeRendererOptions);
 }
 
-ResourceManager::~ResourceManager() {}
+ResourceManager::~ResourceManager() = default;
 
 }}

src/Magnum/Text/AbstractFont.cpp

@@ -165,7 +165,7 @@ std::unique_ptr<AbstractLayouter> AbstractFont::layout(const GlyphCache& cache,
 
 AbstractLayouter::AbstractLayouter(UnsignedInt glyphCount): _glyphCount(glyphCount) {}
 
-AbstractLayouter::~AbstractLayouter() {}
+AbstractLayouter::~AbstractLayouter() = default;
 
 std::pair<Range2D, Range2D> AbstractLayouter::renderGlyph(const UnsignedInt i, Vector2& cursorPosition, Range2D& rectangle) {
     CORRADE_ASSERT(i < glyphCount(), "Text::AbstractLayouter::renderGlyph(): glyph index out of bounds", {});

src/Magnum/Text/Renderer.cpp

@@ -330,7 +330,7 @@ AbstractRenderer::AbstractRenderer(AbstractFont& font, const GlyphCache& cache,
     _mesh.setPrimitive(MeshPrimitive::Triangles);
 }
 
-AbstractRenderer::~AbstractRenderer() {}
+AbstractRenderer::~AbstractRenderer() = default;
 
 template<UnsignedInt dimensions> Renderer<dimensions>::Renderer(AbstractFont& font, const GlyphCache& cache, const Float size, const Alignment alignment): AbstractRenderer(font, cache, size, alignment) {
     /* Finalize mesh configuration */

src/Magnum/TextureArray.cpp

@@ -40,8 +40,8 @@ namespace Magnum {
 
 namespace {
     template<UnsignedInt> struct VectorOrScalar;
-    template<> struct VectorOrScalar<1> { typedef Int Type; };
+    template<> struct VectorOrScalar<1> { using Type = Int; };
-    template<> struct VectorOrScalar<2> { typedef Vector2i Type; };
+    template<> struct VectorOrScalar<2> { using Type = Vector2i; };
 }
 
 template<UnsignedInt dimensions> VectorTypeFor<dimensions+1, Int> TextureArray<dimensions>::maxSize() {

src/Magnum/TextureTools/DistanceField.cpp

@@ -77,12 +77,12 @@ class DistanceFieldShader: public AbstractShaderProgram {
     private:
         enum: Int { TextureUnit = 8 };
 
-        Int radiusUniform,
+        Int radiusUniform{0},
-            scalingUniform,
+            scalingUniform{1},
             imageSizeInvertedUniform;
 };
 
-DistanceFieldShader::DistanceFieldShader(): radiusUniform(0), scalingUniform(1) {
+DistanceFieldShader::DistanceFieldShader() {
     #ifdef MAGNUM_BUILD_STATIC
     /* Import resources on static build, if not already */
     if(!Utility::Resource::hasGroup("MagnumTextureTools"))

src/Magnum/Trade/AbstractMaterialData.cpp

@@ -31,7 +31,7 @@ namespace Magnum { namespace Trade {
 
 AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState) noexcept: _type{type}, _importerState{importerState} {}
 
-AbstractMaterialData::~AbstractMaterialData() {}
+AbstractMaterialData::~AbstractMaterialData() = default;
 
 Debug& operator<<(Debug& debug, const MaterialType value) {
     switch(value) {

src/Magnum/Trade/PhongMaterialData.cpp

@@ -27,7 +27,7 @@
 
 namespace Magnum { namespace Trade {
 
-PhongMaterialData::PhongMaterialData(PhongMaterialData&& other) noexcept: AbstractMaterialData{std::move(other)}, _flags{std::move(other._flags)}, _shininess{std::move(other._shininess)} {
+PhongMaterialData::PhongMaterialData(PhongMaterialData&& other) noexcept: AbstractMaterialData{std::move(other)}, _flags{other._flags}, _shininess{other._shininess} {
     if(_flags & Flag::AmbientTexture)
         _ambient.texture = other._ambient.texture;
     else

src/Magnum/Version.cpp

@@ -33,7 +33,7 @@ namespace Magnum {
 Debug& operator<<(Debug& debug, Version value) {
     switch(value) {
         /* LCOV_EXCL_START */
-        #define _c(value, string) case Version::value: return debug << string;
+        #define _c(value, string) case Version::value: return debug << (string);
         _c(None, "None")
         #ifndef MAGNUM_TARGET_GLES
         _c(GL210, "OpenGL 2.1")

src/MagnumPlugins/ObjImporter/ObjImporter.cpp

@@ -53,7 +53,7 @@ void ignoreLine(std::istream& in) {
     in.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
 }
 
-template<std::size_t size> Math::Vector<size, Float> extractFloatData(std::string str, Float* extra = nullptr) {
+template<std::size_t size> Math::Vector<size, Float> extractFloatData(const std::string& str, Float* extra = nullptr) {
     std::vector<std::string> data = Utility::String::splitWithoutEmptyParts(str, ' ');
     if(data.size() < size || data.size() > size + (extra ? 1 : 0)) {
         Error() << "Trade::ObjImporter::mesh3D(): invalid float array size";