Trade: make most constructors and assignments noexcept.

10 years ago · 1bfa4c9846
20 changed files with 57 additions and 57 deletions
--- a/src/Magnum/Image.cpp
+++ b/src/Magnum/Image.cpp
@ -27,7 +27,7 @@

 namespace Magnum {

-template<UnsignedInt dimensions> Image<dimensions>::Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} {
+template<UnsignedInt dimensions> Image<dimensions>::Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} {
    CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Image::Image(): bad image data size, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this), );
 }

--- a/src/Magnum/Image.h
+++ b/src/Magnum/Image.h
@ -59,19 +59,19 @@ template<UnsignedInt dimensions> class Image {
         * The data are expected to be of proper size for given @p storage
         * parameters.
         */
-        explicit Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data);
+        explicit Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept;

        /** @overload
         * Similar to the above, but uses default @ref PixelStorage parameters.
         */
-        explicit Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): Image{{}, format, type, size, std::move(data)} {}
+        explicit Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{{}, format, type, size, std::move(data)} {}

        #ifdef MAGNUM_BUILD_DEPRECATED
        /** @copybrief Image(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
         * @deprecated Use @ref Image(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
         *      instead.
         */
-        explicit CORRADE_DEPRECATED("use Image(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data): Image{{}, format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Implementation::imageDataSizeFor(format, type, size)}} {}
+        explicit CORRADE_DEPRECATED("use Image(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data) noexcept: Image{{}, format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Implementation::imageDataSizeFor(format, type, size)}} {}
        #endif

        /**
@ -87,12 +87,12 @@ template<UnsignedInt dimensions> class Image {
         * @ref AbstractFramebuffer::read() "*Framebuffer::read()" to fill the
         * image with data using @p storage settings.
         */
-        /*implicit*/ Image(PixelStorage storage, PixelFormat format, PixelType type): _storage{storage}, _format{format}, _type{type}, _data{} {}
+        /*implicit*/ Image(PixelStorage storage, PixelFormat format, PixelType type) noexcept: _storage{storage}, _format{format}, _type{type}, _data{} {}

        /** @overload
         * Similar to the above, but uses default @ref PixelStorage parameters.
         */
-        /*implicit*/ Image(PixelFormat format, PixelType type): Image{{}, format, type} {}
+        /*implicit*/ Image(PixelFormat format, PixelType type) noexcept: Image{{}, format, type} {}

        /** @brief Copying is not allowed */
        Image(const Image<dimensions>&) = delete;
--- a/src/Magnum/Trade/AbstractMaterialData.cpp
+++ b/src/Magnum/Trade/AbstractMaterialData.cpp
@ -29,7 +29,7 @@

 namespace Magnum { namespace Trade {

-AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState): _type{type}, _importerState{importerState} {}
+AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState) noexcept: _type{type}, _importerState{importerState} {}

 AbstractMaterialData::~AbstractMaterialData() {}

--- a/src/Magnum/Trade/AbstractMaterialData.h
+++ b/src/Magnum/Trade/AbstractMaterialData.h
@ -50,27 +50,19 @@ Subclasses provide access to parameters for given material type.
 */
 class MAGNUM_EXPORT AbstractMaterialData {
    public:
-        /**
-         * @brief Constructor
-         * @param type              Material type
-         * @param importerState     Importer-specific state
-         */
-        explicit AbstractMaterialData(MaterialType type, const void* importerState = nullptr);
-
-        /** @brief Destructor */
-        virtual ~AbstractMaterialData() = 0;
+        virtual ~AbstractMaterialData();

        /** @brief Copying is not allowed */
        AbstractMaterialData(const AbstractMaterialData&) = delete;

        /** @brief Move constructor */
-        AbstractMaterialData(AbstractMaterialData&&) = default;
+        AbstractMaterialData(AbstractMaterialData&&) noexcept = default;

        /** @brief Copying is not allowed */
        AbstractMaterialData& operator=(const AbstractMaterialData&) = delete;

        /** @brief Move assignment */
-        AbstractMaterialData& operator=(AbstractMaterialData&&) = default;
+        AbstractMaterialData& operator=(AbstractMaterialData&&) noexcept = default;

        /** @brief Material type */
        MaterialType type() const { return _type; }
@ -82,6 +74,14 @@ class MAGNUM_EXPORT AbstractMaterialData {
         */
        const void* importerState() const { return _importerState; }

+    protected:
+        /**
+         * @brief Constructor
+         * @param type              Material type
+         * @param importerState     Importer-specific state
+         */
+        explicit AbstractMaterialData(MaterialType type, const void* importerState = nullptr) noexcept;
+
    private:
        MaterialType _type;
        const void* _importerState;
--- a/src/Magnum/Trade/ImageData.cpp
+++ b/src/Magnum/Trade/ImageData.cpp
@ -27,7 +27,7 @@

 namespace Magnum { namespace Trade {

-template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState): _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)}, _importerState{importerState} {
+template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)}, _importerState{importerState} {
    CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Trade::ImageData::ImageData(): bad image data size, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this), );
 }

--- a/src/Magnum/Trade/ImageData.h
+++ b/src/Magnum/Trade/ImageData.h
@ -68,18 +68,18 @@ template<UnsignedInt dimensions> class ImageData {
         * The data are expected to be of proper size for given @p storage
         * parameters.
         */
-        explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;

        /** @overload
         * Similar to the above, but uses default @ref PixelStorage parameters.
         */
-        explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr): ImageData{{}, format, type, size, std::move(data), importerState} {}
+        explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept: ImageData{{}, format, type, size, std::move(data), importerState} {}

        #ifdef MAGNUM_BUILD_DEPRECATED
        /** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
         * @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*) instead.
         */
-        explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data): ImageData{format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {}
+        explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data) noexcept: ImageData{format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {}
        #endif

        #ifndef MAGNUM_TARGET_GLES
@ -97,7 +97,7 @@ template<UnsignedInt dimensions> class ImageData {
         * @requires_gl Compressed pixel storage is hardcoded in OpenGL ES and
         *      WebGL.
         */
-        explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
        #endif

        /**
@ -110,7 +110,7 @@ template<UnsignedInt dimensions> class ImageData {
         * Similar the above, but uses default @ref CompressedPixelStorage
         * parameters (or the hardcoded ones in OpenGL ES and WebGL).
         */
-        explicit ImageData(CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;

        /** @brief Copying is not allowed */
        ImageData(const ImageData<dimensions>&) = delete;
@ -297,14 +297,14 @@ template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(
    #ifndef MAGNUM_TARGET_GLES
    const CompressedPixelStorage storage,
    #endif
-    const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState): _compressed{true},
+    const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState) noexcept: _compressed{true},
    #ifndef MAGNUM_TARGET_GLES
    _compressedStorage{storage},
    #endif
    _compressedFormat{format}, _size{size}, _data{std::move(data)}, _importerState{importerState} {}

 #ifndef MAGNUM_TARGET_GLES
-template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState): ImageData{{}, format, size, std::move(data), importerState} {}
+template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{{}, format, size, std::move(data), importerState} {}
 #endif

 template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)}, _importerState{std::move(other._importerState)} {
--- a/src/Magnum/Trade/MeshData2D.cpp
+++ b/src/Magnum/Trade/MeshData2D.cpp
@ -33,11 +33,11 @@ MeshData2D::MeshData2D(const MeshPrimitive primitive, std::vector<UnsignedInt> i
    CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData2D: no position array specified", );
 }

-MeshData2D::MeshData2D(MeshData2D&&) = default;
+MeshData2D::MeshData2D(MeshData2D&&) noexcept = default;

 MeshData2D::~MeshData2D() = default;

-MeshData2D& MeshData2D::operator=(MeshData2D&&) = default;
+MeshData2D& MeshData2D::operator=(MeshData2D&&) noexcept = default;

 std::vector<UnsignedInt>& MeshData2D::indices() {
    CORRADE_ASSERT(isIndexed(), "Trade::MeshData2D::indices(): the mesh is not indexed", _indices);
--- a/src/Magnum/Trade/MeshData2D.h
+++ b/src/Magnum/Trade/MeshData2D.h
@ -62,7 +62,7 @@ class MAGNUM_EXPORT MeshData2D {
        MeshData2D(const MeshData2D&) = delete;

        /** @brief Move constructor */
-        MeshData2D(MeshData2D&&);
+        MeshData2D(MeshData2D&&) noexcept;

        ~MeshData2D();

@ -70,7 +70,7 @@ class MAGNUM_EXPORT MeshData2D {
        MeshData2D& operator=(const MeshData2D&) = delete;

        /** @brief Move assignment */
-        MeshData2D& operator=(MeshData2D&&);
+        MeshData2D& operator=(MeshData2D&&) noexcept;

        /** @brief Primitive */
        MeshPrimitive primitive() const { return _primitive; }
--- a/src/Magnum/Trade/MeshData3D.cpp
+++ b/src/Magnum/Trade/MeshData3D.cpp
@ -33,11 +33,11 @@ MeshData3D::MeshData3D(const MeshPrimitive primitive, std::vector<UnsignedInt> i
    CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData3D: no position array specified", );
 }

-MeshData3D::MeshData3D(MeshData3D&&) = default;
+MeshData3D::MeshData3D(MeshData3D&&) noexcept = default;

 MeshData3D::~MeshData3D() = default;

-MeshData3D& MeshData3D::operator=(MeshData3D&&) = default;
+MeshData3D& MeshData3D::operator=(MeshData3D&&) noexcept = default;

 std::vector<UnsignedInt>& MeshData3D::indices() {
    CORRADE_ASSERT(isIndexed(), "Trade::MeshData3D::indices(): the mesh is not indexed", _indices);
--- a/src/Magnum/Trade/MeshData3D.h
+++ b/src/Magnum/Trade/MeshData3D.h
@ -63,7 +63,7 @@ class MAGNUM_EXPORT MeshData3D {
        MeshData3D(const MeshData3D&) = delete;

        /** @brief Move constructor */
-        MeshData3D(MeshData3D&&);
+        MeshData3D(MeshData3D&&) noexcept;

        ~MeshData3D();

@ -71,7 +71,7 @@ class MAGNUM_EXPORT MeshData3D {
        MeshData3D& operator=(const MeshData3D&) = delete;

        /** @brief Move assignment */
-        MeshData3D& operator=(MeshData3D&&);
+        MeshData3D& operator=(MeshData3D&&) noexcept;

        /** @brief Primitive */
        MeshPrimitive primitive() const { return _primitive; }
--- a/src/Magnum/Trade/MeshObjectData2D.h
+++ b/src/Magnum/Trade/MeshObjectData2D.h
@ -57,13 +57,13 @@ class MAGNUM_EXPORT MeshObjectData2D: public ObjectData2D {
        MeshObjectData2D(const MeshObjectData2D&) = delete;

        /** @brief Move constructor */
-        MeshObjectData2D(MeshObjectData2D&&) = default;
+        MeshObjectData2D(MeshObjectData2D&&) noexcept = default;

        /** @brief Copying is not allowed */
        MeshObjectData2D& operator=(const MeshObjectData2D&) = delete;

        /** @brief Move assignment */
-        MeshObjectData2D& operator=(MeshObjectData2D&&) = default;
+        MeshObjectData2D& operator=(MeshObjectData2D&&) noexcept = default;

        /**
         * @brief Material ID
--- a/src/Magnum/Trade/MeshObjectData3D.h
+++ b/src/Magnum/Trade/MeshObjectData3D.h
@ -57,13 +57,13 @@ class MAGNUM_EXPORT MeshObjectData3D: public ObjectData3D {
        MeshObjectData3D(const MeshObjectData3D&) = delete;

        /** @brief Move constructor */
-        MeshObjectData3D(MeshObjectData3D&&) = default;
+        MeshObjectData3D(MeshObjectData3D&&) noexcept = default;

        /** @brief Copying is not allowed */
        MeshObjectData3D& operator=(const MeshObjectData3D&) = delete;

        /** @brief Move assignment */
-        MeshObjectData3D& operator=(MeshObjectData3D&&) = default;
+        MeshObjectData3D& operator=(MeshObjectData3D&&) noexcept = default;

        /**
         * @brief Material ID
--- a/src/Magnum/Trade/ObjectData2D.cpp
+++ b/src/Magnum/Trade/ObjectData2D.cpp
@ -31,11 +31,11 @@ ObjectData2D::ObjectData2D(std::vector<UnsignedInt> children, const Matrix3& tra

 ObjectData2D::ObjectData2D(std::vector<UnsignedInt> children, const Matrix3& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType2D::Empty}, _instance{-1}, _importerState{importerState} {}

-ObjectData2D::ObjectData2D(ObjectData2D&&) = default;
+ObjectData2D::ObjectData2D(ObjectData2D&&) noexcept = default;

 ObjectData2D::~ObjectData2D() = default;

-ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) = default;
+ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) noexcept = default;

 #ifndef DOXYGEN_GENERATING_OUTPUT
 Debug& operator<<(Debug& debug, ObjectInstanceType2D value) {
--- a/src/Magnum/Trade/ObjectData2D.h
+++ b/src/Magnum/Trade/ObjectData2D.h
@ -83,7 +83,7 @@ class MAGNUM_EXPORT ObjectData2D {
        ObjectData2D(const ObjectData2D&) = delete;

        /** @brief Move constructor */
-        ObjectData2D(ObjectData2D&&);
+        ObjectData2D(ObjectData2D&&) noexcept;

        /** @brief Destructor */
        virtual ~ObjectData2D();
@ -92,7 +92,7 @@ class MAGNUM_EXPORT ObjectData2D {
        ObjectData2D& operator=(const ObjectData2D&) = delete;

        /** @brief Move assignment */
-        ObjectData2D& operator=(ObjectData2D&&);
+        ObjectData2D& operator=(ObjectData2D&&) noexcept;

        /** @brief Child objects */
        std::vector<UnsignedInt>& children() { return _children; }
--- a/src/Magnum/Trade/ObjectData3D.cpp
+++ b/src/Magnum/Trade/ObjectData3D.cpp
@ -31,11 +31,11 @@ ObjectData3D::ObjectData3D(std::vector<UnsignedInt> children, const Matrix4& tra

 ObjectData3D::ObjectData3D(std::vector<UnsignedInt> children, const Matrix4& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType3D::Empty}, _instance{-1}, _importerState{importerState} {}

-ObjectData3D::ObjectData3D(ObjectData3D&&) = default;
+ObjectData3D::ObjectData3D(ObjectData3D&&) noexcept = default;

 ObjectData3D::~ObjectData3D() = default;

-ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) = default;
+ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) noexcept = default;

 #ifndef DOXYGEN_GENERATING_OUTPUT
 Debug& operator<<(Debug& debug, ObjectInstanceType3D value) {
--- a/src/Magnum/Trade/ObjectData3D.h
+++ b/src/Magnum/Trade/ObjectData3D.h
@ -85,7 +85,7 @@ class MAGNUM_EXPORT ObjectData3D {
        ObjectData3D(const ObjectData3D&) = delete;

        /** @brief Move constructor */
-        ObjectData3D(ObjectData3D&&);
+        ObjectData3D(ObjectData3D&&) noexcept;

        /** @brief Destructor */
        virtual ~ObjectData3D();
@ -94,7 +94,7 @@ class MAGNUM_EXPORT ObjectData3D {
        ObjectData3D& operator=(const ObjectData3D&) = delete;

        /** @brief Move assignment */
-        ObjectData3D& operator=(ObjectData3D&&);
+        ObjectData3D& operator=(ObjectData3D&&) noexcept;

        /** @brief Child objects */
        std::vector<UnsignedInt>& children() { return _children; }
--- a/src/Magnum/Trade/PhongMaterialData.h
+++ b/src/Magnum/Trade/PhongMaterialData.h
@ -73,7 +73,7 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
         * Colors and textures should be specified using member functions based
         * on what flags are set.
         */
-        explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr): AbstractMaterialData{MaterialType::Phong, importerState}, _shininess{shininess}, _flags{flags} {}
+        explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr) noexcept: AbstractMaterialData{MaterialType::Phong, importerState}, _flags{flags}, _shininess{shininess} {}

        /** @brief Material flags */
        Flags flags() const { return _flags; }
@ -139,15 +139,15 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
        union Source {
            Source() {}

-            Vector3 color;
+            Color3 color;
            UnsignedInt texture;
        };

+        Flags _flags;
+        Float _shininess;
        Source _ambient,
            _diffuse,
            _specular;
-        Float _shininess;
-        Flags _flags;
 };

 CORRADE_ENUMSET_OPERATORS(PhongMaterialData::Flags)
--- a/src/Magnum/Trade/SceneData.cpp
+++ b/src/Magnum/Trade/SceneData.cpp
@ -29,8 +29,8 @@ namespace Magnum { namespace Trade {

 SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* const importerState): _children2D{std::move(children2D)}, _children3D{std::move(children3D)}, _importerState{importerState} {}

-SceneData::SceneData(SceneData&&) = default;
+SceneData::SceneData(SceneData&&) noexcept = default;

-SceneData& SceneData::operator=(SceneData&&) = default;
+SceneData& SceneData::operator=(SceneData&&) noexcept = default;

 }}
--- a/src/Magnum/Trade/SceneData.h
+++ b/src/Magnum/Trade/SceneData.h
@ -54,13 +54,13 @@ class MAGNUM_EXPORT SceneData {
        SceneData(const SceneData&) = delete;

        /** @brief Move constructor */
-        SceneData(SceneData&&);
+        SceneData(SceneData&&) noexcept;

        /** @brief Copying is not allowed */
        SceneData& operator=(const SceneData&) = delete;

        /** @brief Move assignment */
-        SceneData& operator=(SceneData&&);
+        SceneData& operator=(SceneData&&) noexcept;

        /** @brief Two-dimensional child objects */
        const std::vector<UnsignedInt>& children2D() const { return _children2D; }
--- a/src/Magnum/Trade/TextureData.h
+++ b/src/Magnum/Trade/TextureData.h
@ -62,19 +62,19 @@ class TextureData {
         * @param image                 Texture image ID
         * @param importerState         Importer-specific state
         */
-        TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D<Sampler::Wrapping> wrapping, UnsignedInt image, const void* importerState = nullptr): _type{type}, _minificationFilter{minificationFilter}, _magnificationFilter{magnificationFilter}, _mipmapFilter{mipmapFilter}, _wrapping{wrapping}, _image{image}, _importerState{importerState} {}
+        TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D<Sampler::Wrapping> wrapping, UnsignedInt image, const void* importerState = nullptr) noexcept: _type{type}, _minificationFilter{minificationFilter}, _magnificationFilter{magnificationFilter}, _mipmapFilter{mipmapFilter}, _wrapping{wrapping}, _image{image}, _importerState{importerState} {}

        /** @brief Copying is not allowed */
        TextureData(const TextureData&) = delete;

        /** @brief Move constructor */
-        TextureData(TextureData&&) = default;
+        TextureData(TextureData&&) noexcept = default;

        /** @brief Copying is not allowed */
        TextureData& operator=(const TextureData&) = delete;

        /** @brief Move assignment */
-        TextureData& operator=(TextureData&&) = default;
+        TextureData& operator=(TextureData&&) noexcept = default;

        /** @brief Texture type */
        Type type() const { return _type; }