From d1ce761cce6d7ccf8c54b98c5c917c7845a88483 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sun, 11 Sep 2016 23:37:45 +0200 Subject: [PATCH] Trade: conditionally disable noexcept for GCC 4.9.0 in Android NDK. It complains about singatures not matching the implicit and thus not being defaultable. Works everywhere else, even on GCC 4.7 and 5.0, so I don't bother. --- src/Magnum/Trade/MeshData2D.cpp | 12 ++++++++++-- src/Magnum/Trade/MeshData2D.h | 18 ++++++++++++++++-- src/Magnum/Trade/MeshData3D.cpp | 12 ++++++++++-- src/Magnum/Trade/MeshData3D.h | 18 ++++++++++++++++-- src/Magnum/Trade/MeshObjectData2D.h | 18 ++++++++++++++++-- src/Magnum/Trade/MeshObjectData3D.h | 18 ++++++++++++++++-- src/Magnum/Trade/ObjectData2D.cpp | 12 ++++++++++-- src/Magnum/Trade/ObjectData2D.h | 18 ++++++++++++++++-- src/Magnum/Trade/ObjectData3D.cpp | 12 ++++++++++-- src/Magnum/Trade/ObjectData3D.h | 18 ++++++++++++++++-- src/Magnum/Trade/SceneData.cpp | 14 +++++++++++--- src/Magnum/Trade/SceneData.h | 18 ++++++++++++++++-- 12 files changed, 163 insertions(+), 25 deletions(-) diff --git a/src/Magnum/Trade/MeshData2D.cpp b/src/Magnum/Trade/MeshData2D.cpp index 4333e8ee2..2e986ced1 100644 --- a/src/Magnum/Trade/MeshData2D.cpp +++ b/src/Magnum/Trade/MeshData2D.cpp @@ -33,11 +33,19 @@ MeshData2D::MeshData2D(const MeshPrimitive primitive, std::vector i CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData2D: no position array specified", ); } -MeshData2D::MeshData2D(MeshData2D&&) noexcept = default; +MeshData2D::MeshData2D(MeshData2D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; MeshData2D::~MeshData2D() = default; -MeshData2D& MeshData2D::operator=(MeshData2D&&) noexcept = default; +MeshData2D& MeshData2D::operator=(MeshData2D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; std::vector& MeshData2D::indices() { CORRADE_ASSERT(isIndexed(), "Trade::MeshData2D::indices(): the mesh is not indexed", _indices); diff --git a/src/Magnum/Trade/MeshData2D.h b/src/Magnum/Trade/MeshData2D.h index bfb566f65..30bc4b4d6 100644 --- a/src/Magnum/Trade/MeshData2D.h +++ b/src/Magnum/Trade/MeshData2D.h @@ -62,7 +62,14 @@ class MAGNUM_EXPORT MeshData2D { MeshData2D(const MeshData2D&) = delete; /** @brief Move constructor */ - MeshData2D(MeshData2D&&) noexcept; + MeshData2D(MeshData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; ~MeshData2D(); @@ -70,7 +77,14 @@ class MAGNUM_EXPORT MeshData2D { MeshData2D& operator=(const MeshData2D&) = delete; /** @brief Move assignment */ - MeshData2D& operator=(MeshData2D&&) noexcept; + MeshData2D& operator=(MeshData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Primitive */ MeshPrimitive primitive() const { return _primitive; } diff --git a/src/Magnum/Trade/MeshData3D.cpp b/src/Magnum/Trade/MeshData3D.cpp index 549e23311..72d190930 100644 --- a/src/Magnum/Trade/MeshData3D.cpp +++ b/src/Magnum/Trade/MeshData3D.cpp @@ -33,11 +33,19 @@ MeshData3D::MeshData3D(const MeshPrimitive primitive, std::vector i CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData3D: no position array specified", ); } -MeshData3D::MeshData3D(MeshData3D&&) noexcept = default; +MeshData3D::MeshData3D(MeshData3D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; MeshData3D::~MeshData3D() = default; -MeshData3D& MeshData3D::operator=(MeshData3D&&) noexcept = default; +MeshData3D& MeshData3D::operator=(MeshData3D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; std::vector& MeshData3D::indices() { CORRADE_ASSERT(isIndexed(), "Trade::MeshData3D::indices(): the mesh is not indexed", _indices); diff --git a/src/Magnum/Trade/MeshData3D.h b/src/Magnum/Trade/MeshData3D.h index eb3fea4c5..0f800f2e2 100644 --- a/src/Magnum/Trade/MeshData3D.h +++ b/src/Magnum/Trade/MeshData3D.h @@ -63,7 +63,14 @@ class MAGNUM_EXPORT MeshData3D { MeshData3D(const MeshData3D&) = delete; /** @brief Move constructor */ - MeshData3D(MeshData3D&&) noexcept; + MeshData3D(MeshData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; ~MeshData3D(); @@ -71,7 +78,14 @@ class MAGNUM_EXPORT MeshData3D { MeshData3D& operator=(const MeshData3D&) = delete; /** @brief Move assignment */ - MeshData3D& operator=(MeshData3D&&) noexcept; + MeshData3D& operator=(MeshData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Primitive */ MeshPrimitive primitive() const { return _primitive; } diff --git a/src/Magnum/Trade/MeshObjectData2D.h b/src/Magnum/Trade/MeshObjectData2D.h index f103fd10e..7ef931d6e 100644 --- a/src/Magnum/Trade/MeshObjectData2D.h +++ b/src/Magnum/Trade/MeshObjectData2D.h @@ -57,13 +57,27 @@ class MAGNUM_EXPORT MeshObjectData2D: public ObjectData2D { MeshObjectData2D(const MeshObjectData2D&) = delete; /** @brief Move constructor */ - MeshObjectData2D(MeshObjectData2D&&) noexcept = default; + MeshObjectData2D(MeshObjectData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; /** @brief Copying is not allowed */ MeshObjectData2D& operator=(const MeshObjectData2D&) = delete; /** @brief Move assignment */ - MeshObjectData2D& operator=(MeshObjectData2D&&) noexcept = default; + MeshObjectData2D& operator=(MeshObjectData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; /** * @brief Material ID diff --git a/src/Magnum/Trade/MeshObjectData3D.h b/src/Magnum/Trade/MeshObjectData3D.h index 082e75166..96e6dbc37 100644 --- a/src/Magnum/Trade/MeshObjectData3D.h +++ b/src/Magnum/Trade/MeshObjectData3D.h @@ -57,13 +57,27 @@ class MAGNUM_EXPORT MeshObjectData3D: public ObjectData3D { MeshObjectData3D(const MeshObjectData3D&) = delete; /** @brief Move constructor */ - MeshObjectData3D(MeshObjectData3D&&) noexcept = default; + MeshObjectData3D(MeshObjectData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; /** @brief Copying is not allowed */ MeshObjectData3D& operator=(const MeshObjectData3D&) = delete; /** @brief Move assignment */ - MeshObjectData3D& operator=(MeshObjectData3D&&) noexcept = default; + MeshObjectData3D& operator=(MeshObjectData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; /** * @brief Material ID diff --git a/src/Magnum/Trade/ObjectData2D.cpp b/src/Magnum/Trade/ObjectData2D.cpp index 8ec678f35..08b182331 100644 --- a/src/Magnum/Trade/ObjectData2D.cpp +++ b/src/Magnum/Trade/ObjectData2D.cpp @@ -31,11 +31,19 @@ ObjectData2D::ObjectData2D(std::vector children, const Matrix3& tra ObjectData2D::ObjectData2D(std::vector children, const Matrix3& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType2D::Empty}, _instance{-1}, _importerState{importerState} {} -ObjectData2D::ObjectData2D(ObjectData2D&&) noexcept = default; +ObjectData2D::ObjectData2D(ObjectData2D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; ObjectData2D::~ObjectData2D() = default; -ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) noexcept = default; +ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; #ifndef DOXYGEN_GENERATING_OUTPUT Debug& operator<<(Debug& debug, ObjectInstanceType2D value) { diff --git a/src/Magnum/Trade/ObjectData2D.h b/src/Magnum/Trade/ObjectData2D.h index a95cf7f1d..589119984 100644 --- a/src/Magnum/Trade/ObjectData2D.h +++ b/src/Magnum/Trade/ObjectData2D.h @@ -83,7 +83,14 @@ class MAGNUM_EXPORT ObjectData2D { ObjectData2D(const ObjectData2D&) = delete; /** @brief Move constructor */ - ObjectData2D(ObjectData2D&&) noexcept; + ObjectData2D(ObjectData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Destructor */ virtual ~ObjectData2D(); @@ -92,7 +99,14 @@ class MAGNUM_EXPORT ObjectData2D { ObjectData2D& operator=(const ObjectData2D&) = delete; /** @brief Move assignment */ - ObjectData2D& operator=(ObjectData2D&&) noexcept; + ObjectData2D& operator=(ObjectData2D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Child objects */ std::vector& children() { return _children; } diff --git a/src/Magnum/Trade/ObjectData3D.cpp b/src/Magnum/Trade/ObjectData3D.cpp index 900156383..0a1d2c843 100644 --- a/src/Magnum/Trade/ObjectData3D.cpp +++ b/src/Magnum/Trade/ObjectData3D.cpp @@ -31,11 +31,19 @@ ObjectData3D::ObjectData3D(std::vector children, const Matrix4& tra ObjectData3D::ObjectData3D(std::vector children, const Matrix4& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType3D::Empty}, _instance{-1}, _importerState{importerState} {} -ObjectData3D::ObjectData3D(ObjectData3D&&) noexcept = default; +ObjectData3D::ObjectData3D(ObjectData3D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; ObjectData3D::~ObjectData3D() = default; -ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) noexcept = default; +ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; #ifndef DOXYGEN_GENERATING_OUTPUT Debug& operator<<(Debug& debug, ObjectInstanceType3D value) { diff --git a/src/Magnum/Trade/ObjectData3D.h b/src/Magnum/Trade/ObjectData3D.h index 0bf7a3f1f..042a91acf 100644 --- a/src/Magnum/Trade/ObjectData3D.h +++ b/src/Magnum/Trade/ObjectData3D.h @@ -84,7 +84,14 @@ class MAGNUM_EXPORT ObjectData3D { ObjectData3D(const ObjectData3D&) = delete; /** @brief Move constructor */ - ObjectData3D(ObjectData3D&&) noexcept; + ObjectData3D(ObjectData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Destructor */ virtual ~ObjectData3D(); @@ -93,7 +100,14 @@ class MAGNUM_EXPORT ObjectData3D { ObjectData3D& operator=(const ObjectData3D&) = delete; /** @brief Move assignment */ - ObjectData3D& operator=(ObjectData3D&&) noexcept; + ObjectData3D& operator=(ObjectData3D&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Child objects */ std::vector& children() { return _children; } diff --git a/src/Magnum/Trade/SceneData.cpp b/src/Magnum/Trade/SceneData.cpp index b51449f91..9b656e9dd 100644 --- a/src/Magnum/Trade/SceneData.cpp +++ b/src/Magnum/Trade/SceneData.cpp @@ -29,8 +29,16 @@ namespace Magnum { namespace Trade { SceneData::SceneData(std::vector children2D, std::vector children3D, const void* const importerState): _children2D{std::move(children2D)}, _children3D{std::move(children3D)}, _importerState{importerState} {} -SceneData::SceneData(SceneData&&) noexcept = default; - -SceneData& SceneData::operator=(SceneData&&) noexcept = default; +SceneData::SceneData(SceneData&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; + +SceneData& SceneData::operator=(SceneData&&) + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + = default; }} diff --git a/src/Magnum/Trade/SceneData.h b/src/Magnum/Trade/SceneData.h index edaba4bff..d6707ae32 100644 --- a/src/Magnum/Trade/SceneData.h +++ b/src/Magnum/Trade/SceneData.h @@ -54,13 +54,27 @@ class MAGNUM_EXPORT SceneData { SceneData(const SceneData&) = delete; /** @brief Move constructor */ - SceneData(SceneData&&) noexcept; + SceneData(SceneData&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Copying is not allowed */ SceneData& operator=(const SceneData&) = delete; /** @brief Move assignment */ - SceneData& operator=(SceneData&&) noexcept; + SceneData& operator=(SceneData&&) + /* GCC 4.9.0 (the one from Android NDK) thinks this does not match + the implicit signature so it can't be defaulted. Works on 4.7, + 5.0 and everywhere else, so I don't bother. */ + #if !defined(__GNUC__) || __GNUC__*100 + __GNUC_MINOR__ != 409 + noexcept + #endif + ; /** @brief Two-dimensional child objects */ const std::vector& children2D() const { return _children2D; }