Get rid of std::unique_ptr.

doc/changelog.dox

@@ -123,6 +123,12 @@ See also:
     @ref Platform::Sdl2Application::redraw() "redraw()" were changed from
     protected to public to allow calling them from outside
 
+@subsubsection changelog-latest-changes-text Text library
+
+-   The @ref Text::AbstractFont and @ref Text::AbstractFontConverter plugin
+    APIs now return @ref Corrade::Containers::Pointer instead of
+    @ref std::unique_ptr for improved compile times
+
 @subsubsection changelog-latest-changes-texturetools TextureTools library
 
 -   Further performance and output quality improvements for
@@ -131,6 +137,12 @@ See also:
     compared to before. It's now also possible to reuse the internal state for
     batch processing.
 
+@subsubsection changelog-latest-changes-trade Trade library
+
+-   The @ref Trade::AbstractImporter plugin API now returns
+    @ref Corrade::Containers::Pointer instead of @ref std::unique_ptr for
+    improved compile times
+
 @subsection changelog-latest-buildsystem Build system
 
 -   Experimental support for creating Android APKs directly using CMake without

doc/generated/primitives.cpp

@@ -144,7 +144,7 @@ namespace {
 
 int PrimitiveVisualizer::exec() {
     PluginManager::Manager<Trade::AbstractImageConverter> converterManager;
-    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate("PngImageConverter");
+    Containers::Pointer<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate("PngImageConverter");
     if(!converter) {
         Error() << "Cannot load image converter plugin";
         std::exit(1);

doc/generated/shaders.cpp

@@ -81,7 +81,7 @@ struct ShaderVisualizer: Platform::WindowlessApplication {
     std::string vector();
     std::string distanceFieldVector();
 
-    std::unique_ptr<Trade::AbstractImporter> _importer;
+    Containers::Pointer<Trade::AbstractImporter> _importer;
 };
 
 namespace {
@@ -90,7 +90,7 @@ namespace {
 
 int ShaderVisualizer::exec() {
     PluginManager::Manager<Trade::AbstractImageConverter> converterManager;
-    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate("PngImageConverter");
+    Containers::Pointer<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate("PngImageConverter");
     if(!converter) {
         Error() << "Cannot load image converter plugin";
         std::exit(1);

doc/snippets/MagnumText.cpp

@@ -35,7 +35,7 @@ int main() {
 
 {
 /* [DistanceFieldGlyphCache-usage] */
-std::unique_ptr<Text::AbstractFont> font;
+Containers::Pointer<Text::AbstractFont> font;
 Text::DistanceFieldGlyphCache cache{Vector2i{2048}, Vector2i{384}, 16};
 font->fillGlyphCache(cache, "abcdefghijklmnopqrstuvwxyz"
                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -45,7 +45,7 @@ font->fillGlyphCache(cache, "abcdefghijklmnopqrstuvwxyz"
 
 {
 /* [GlyphCache-usage] */
-std::unique_ptr<Text::AbstractFont> font;
+Containers::Pointer<Text::AbstractFont> font;
 Text::GlyphCache cache{Vector2i{512}};
 font->fillGlyphCache(cache, "abcdefghijklmnopqrstuvwxyz"
                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -57,7 +57,7 @@ font->fillGlyphCache(cache, "abcdefghijklmnopqrstuvwxyz"
 Matrix3 projectionMatrix;
 /* [Renderer-usage1] */
 /* Font instance, received from a plugin manager */
-std::unique_ptr<Text::AbstractFont> font;
+Containers::Pointer<Text::AbstractFont> font;
 
 /* Configured glyph cache */
 Text::GlyphCache cache{Vector2i{512}};

doc/snippets/MagnumTrade.cpp

@@ -50,7 +50,7 @@ int main() {
 {
 /* [AbstractImporter-usage] */
 PluginManager::Manager<Trade::AbstractImporter> manager;
-std::unique_ptr<Trade::AbstractImporter> importer =
+Containers::Pointer<Trade::AbstractImporter> importer =
     manager.loadAndInstantiate("AnyImageImporter");
 if(!importer || !importer->openFile("image.png"))
     Fatal{} << "Can't open image.png with AnyImageImporter";
@@ -64,7 +64,7 @@ if(!image) Fatal{} << "Importing the image failed";
 
 #if defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT))
 {
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 /* [AbstractImporter-usage-callbacks] */
 struct Data {
     std::unordered_map<std::string,
@@ -96,10 +96,10 @@ importer->openFile("scene.gltf"); // memory-maps all files
 #endif
 
 {
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 Float shininess;
 /* [AbstractImporter-usage-cast] */
-std::unique_ptr<Trade::AbstractMaterialData> data = importer->material(12);
+Containers::Pointer<Trade::AbstractMaterialData> data = importer->material(12);
 if(data && data->type() == Trade::MaterialType::Phong) {
     auto& phong = static_cast<Trade::PhongMaterialData&>(*data);
 
@@ -111,7 +111,7 @@ static_cast<void>(shininess);
 }
 
 {
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 /* [AbstractImporter-setFileCallback] */
 importer->setFileCallback([](const std::string& filename,
     Trade::ImporterFileCallbackPolicy, void*) {
@@ -122,7 +122,7 @@ importer->setFileCallback([](const std::string& filename,
 }
 
 {
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 /* [AbstractImporter-setFileCallback-template] */
 struct Data {
     std::unordered_map<std::string, Containers::Array<char>> files;
@@ -145,7 +145,7 @@ importer->setFileCallback([](const std::string& filename,
 
 {
 UnsignedInt id{};
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 /* [AnimationData-usage] */
 
 Containers::Optional<Trade::AnimationData> data = importer->animation(id);
@@ -184,7 +184,7 @@ Trade::ImageData2D image{CompressedPixelFormat::Bc1RGBUnorm,
 #ifdef MAGNUM_TARGET_GL
 {
 /* [ImageData-usage] */
-std::unique_ptr<Trade::AbstractImporter> importer;
+Containers::Pointer<Trade::AbstractImporter> importer;
 Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
 if(!image) Fatal{} << "Oopsie!";
 

doc/snippets/debugtools-compareimage.cpp

@@ -41,7 +41,7 @@ namespace {
 
 Image2D doProcessing() {
     PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
-    std::unique_ptr<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter");
+    Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter");
     importer->openFile(Utility::Directory::join(SNIPPETS_DIR, "image2.tga"));
     auto image = importer->image2D(0);
     CORRADE_INTERNAL_ASSERT(image);
@@ -50,7 +50,7 @@ Image2D doProcessing() {
 
 Image2D loadExpectedImage() {
     PluginManager::Manager<Trade::AbstractImporter> manager{MAGNUM_PLUGINS_IMPORTER_DIR};
-    std::unique_ptr<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter");
+    Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("TgaImporter");
     importer->openFile(Utility::Directory::join(SNIPPETS_DIR, "image1.tga"));
     auto image = importer->image2D(0);
     CORRADE_INTERNAL_ASSERT(image);

doc/snippets/plugins.cpp

@@ -22,7 +22,7 @@ int main() {
 /* [loading] */
 {
     PluginManager::Manager<Trade::AbstractImporter> manager;
-    std::unique_ptr<Trade::AbstractImporter> importer =
+    Containers::Pointer<Trade::AbstractImporter> importer =
         manager.loadAndInstantiate("TgaImporter");
     if(!importer) Fatal{} << "Cannot load the TgaImporter plugin";
 
@@ -53,7 +53,7 @@ manager.setPreferredPlugins("TrueTypeFont", {"HarfBuzzFont", "FreeTypeFont"});
 {
 PluginManager::Manager<Trade::AbstractImporter> manager;
 /* [anyimporter] */
-std::unique_ptr<Trade::AbstractImporter> importer =
+Containers::Pointer<Trade::AbstractImporter> importer =
     manager.instantiate("AnyImageImporter");
 importer->openFile("texture.dds"); /* Delegates to the DdsImporter plugin */
 /* [anyimporter] */
@@ -62,7 +62,7 @@ importer->openFile("texture.dds"); /* Delegates to the DdsImporter plugin */
 {
 PluginManager::Manager<Trade::AbstractImporter> manager;
 /* [configuration] */
-std::unique_ptr<Trade::AbstractImporter> importer =
+Containers::Pointer<Trade::AbstractImporter> importer =
     manager.instantiate("AssimpImporter");
 importer->configuration().group("postprocess")->setValue("PreTransformVertices", true);
 /* [configuration] */

src/Magnum/DebugTools/CompareImage.cpp

@@ -485,7 +485,7 @@ bool ImageComparatorBase::operator()(const std::string& actual, const std::strin
     _fileState->actualFilename = actual;
     _fileState->expectedFilename = expected;
 
-    std::unique_ptr<Trade::AbstractImporter> importer;
+    Containers::Pointer<Trade::AbstractImporter> importer;
     if(!(importer = _fileState->manager->loadAndInstantiate("AnyImageImporter"))) {
         _state = State::PluginLoadFailed;
         return false;
@@ -521,7 +521,7 @@ bool ImageComparatorBase::operator()(const ImageView2D& actual, const std::strin
 
     _fileState->expectedFilename = expected;
 
-    std::unique_ptr<Trade::AbstractImporter> importer;
+    Containers::Pointer<Trade::AbstractImporter> importer;
     if(!(importer = _fileState->manager->loadAndInstantiate("AnyImageImporter"))) {
         _state = State::PluginLoadFailed;
         return false;
@@ -546,7 +546,7 @@ bool ImageComparatorBase::operator()(const std::string& actual, const ImageView2
 
     _fileState->actualFilename = actual;
 
-    std::unique_ptr<Trade::AbstractImporter> importer;
+    Containers::Pointer<Trade::AbstractImporter> importer;
     if(!(importer = _fileState->manager->loadAndInstantiate("AnyImageImporter"))) {
         _state = State::PluginLoadFailed;
         return false;

src/Magnum/DebugTools/CompareImage.h

@@ -29,8 +29,8 @@
  * @brief Class @ref Magnum::DebugTools::CompareImage
  */
 
-#include <memory>
 #include <vector>
+#include <Corrade/Containers/Pointer.h>
 #include <Corrade/PluginManager/PluginManager.h>
 #include <Corrade/TestSuite/Comparator.h>
 
@@ -80,7 +80,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT ImageComparatorBase {
 
         enum class State: UnsignedByte;
 
-        std::unique_ptr<FileState> _fileState;
+        Containers::Pointer<FileState> _fileState;
         Float _maxThreshold, _meanThreshold;
 
         State _state{};

src/Magnum/GL/Implementation/State.h

@@ -25,7 +25,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include <memory>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/GL/GL.h"
@@ -58,22 +58,22 @@ struct State {
 
     enum: GLuint { DisengagedBinding = ~0u };
 
-    std::unique_ptr<BufferState> buffer;
+    Containers::Pointer<BufferState> buffer;
-    std::unique_ptr<ContextState> context;
+    Containers::Pointer<ContextState> context;
     #ifndef MAGNUM_TARGET_WEBGL
-    std::unique_ptr<DebugState> debug;
+    Containers::Pointer<DebugState> debug;
     #endif
-    std::unique_ptr<FramebufferState> framebuffer;
+    Containers::Pointer<FramebufferState> framebuffer;
-    std::unique_ptr<MeshState> mesh;
+    Containers::Pointer<MeshState> mesh;
     #if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
-    std::unique_ptr<QueryState> query;
+    Containers::Pointer<QueryState> query;
     #endif
-    std::unique_ptr<RendererState> renderer;
+    Containers::Pointer<RendererState> renderer;
-    std::unique_ptr<ShaderState> shader;
+    Containers::Pointer<ShaderState> shader;
-    std::unique_ptr<ShaderProgramState> shaderProgram;
+    Containers::Pointer<ShaderProgramState> shaderProgram;
-    std::unique_ptr<TextureState> texture;
+    Containers::Pointer<TextureState> texture;
     #ifndef MAGNUM_TARGET_GLES2
-    std::unique_ptr<TransformFeedbackState> transformFeedback;
+    Containers::Pointer<TransformFeedbackState> transformFeedback;
     #endif
 };
 

src/Magnum/MeshTools/Compile.h

@@ -38,7 +38,7 @@
 
 #ifdef MAGNUM_BUILD_DEPRECATED
 #include <tuple>
-#include <memory>
+#include <memory> /* deliberately kept here */
 #include <Corrade/Utility/Macros.h>
 #endif
 

src/Magnum/Platform/AbstractXApplication.h

@@ -29,8 +29,8 @@
  * @brief Class @ref Magnum::Platform::AbstractXApplication
  */
 
-#include <memory>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ -280,8 +280,8 @@ class AbstractXApplication {
         Window _window{};
         Atom _deleteWindow{};
 
-        std::unique_ptr<Implementation::AbstractContextHandler<GLConfiguration, Display*, VisualID, Window>> _contextHandler;
+        Containers::Pointer<Implementation::AbstractContextHandler<GLConfiguration, Display*, VisualID, Window>> _contextHandler;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 
         /** @todo Get this from the created window */
         Vector2i _windowSize;

src/Magnum/Platform/AndroidApplication.cpp

@@ -194,10 +194,10 @@ void AndroidApplication::mouseMoveEvent(MouseMoveEvent&) {}
 
 namespace {
     struct Data {
-        Data(std::unique_ptr<AndroidApplication>(*instancer)(const AndroidApplication::Arguments&), void(*nativeActivity)(ANativeActivity*,void*,size_t)): instancer(instancer), nativeActivity{nativeActivity} {}
+        Data(Containers::Pointer<AndroidApplication>(*instancer)(const AndroidApplication::Arguments&), void(*nativeActivity)(ANativeActivity*,void*,size_t)): instancer(instancer), nativeActivity{nativeActivity} {}
 
-        std::unique_ptr<AndroidApplication>(*instancer)(const AndroidApplication::Arguments&);
+        Containers::Pointer<AndroidApplication>(*instancer)(const AndroidApplication::Arguments&);
-        std::unique_ptr<AndroidApplication> instance;
+        Containers::Pointer<AndroidApplication> instance;
 
         void(*nativeActivity)(ANativeActivity*,void*,size_t);
     };
@@ -270,7 +270,7 @@ std::int32_t AndroidApplication::inputEvent(android_app* state, AInputEvent* eve
 AndroidApplication::GLConfiguration::GLConfiguration():
     _colorBufferSize{8, 8, 8, 0}, _depthBufferSize{24}, _stencilBufferSize{0} {}
 
-void AndroidApplication::exec(android_app* state, std::unique_ptr<AndroidApplication>(*instancer)(const Arguments&)) {
+void AndroidApplication::exec(android_app* state, Containers::Pointer<AndroidApplication>(*instancer)(const Arguments&)) {
     state->onAppCmd = commandEvent;
     state->onInputEvent = inputEvent;
 

src/Magnum/Platform/AndroidApplication.h

@@ -31,8 +31,8 @@
  */
 #endif
 
-#include <memory>
 #include <EGL/egl.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -162,11 +162,11 @@ class AndroidApplication {
          *
          * See @ref MAGNUM_ANDROIDAPPLICATION_MAIN() for usage information.
          */
-        static void exec(android_app* state, std::unique_ptr<AndroidApplication>(*instancer)(const Arguments&));
+        static void exec(android_app* state, Containers::Pointer<AndroidApplication>(*instancer)(const Arguments&));
 
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        template<class T> static std::unique_ptr<AndroidApplication> instancer(const Arguments& arguments) {
+        template<class T> static Containers::Pointer<AndroidApplication> instancer(const Arguments& arguments) {
-            return std::unique_ptr<AndroidApplication>{new T{arguments}};
+            return Containers::Pointer<AndroidApplication>{new T{arguments}};
         }
         #endif
 
@@ -450,8 +450,8 @@ class AndroidApplication {
         EGLSurface _surface;
         EGLContext _glContext;
 
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
-        std::unique_ptr<LogOutput> _logOutput;
+        Containers::Pointer<LogOutput> _logOutput;
 
         CORRADE_ENUMSET_FRIEND_OPERATORS(Flags)
 };

src/Magnum/Platform/GlfwApplication.h

@@ -30,10 +30,10 @@
  * @brief Class @ref Magnum::Platform::GlfwApplication, macro @ref MAGNUM_GLFWAPPLICATION_MAIN()
  */
 
-#include <memory>
 #include <string>
 #include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Containers/Optional.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -572,7 +572,7 @@ class GlfwApplication {
         GLFWwindow* _window{nullptr};
         Flags _flags;
         #ifdef MAGNUM_TARGET_GL
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
         #endif
 };
 

src/Magnum/Platform/GlutApplication.h

@@ -34,8 +34,8 @@
     as soon as possible.
 */
 
-#include <memory>
 #include <string>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -406,7 +406,7 @@ class CORRADE_DEPRECATED("scheduled for removal, consider switching to Sdl2Appli
 
         static GlutApplication* _instance;
 
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /**

src/Magnum/Platform/Sdl2Application.h

@@ -29,10 +29,9 @@
  * @brief Class @ref Magnum::Platform::Sdl2Application, macro @ref MAGNUM_SDL2APPLICATION_MAIN()
  */
 
-#include <memory>
-#include <Corrade/Corrade.h>
 #include <Corrade/Containers/ArrayView.h>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -1005,7 +1004,7 @@ class Sdl2Application {
         #else
         SDL_Surface* _glContext{};
         #endif
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
         #endif
 
         Flags _flags;

src/Magnum/Platform/WindowlessCglApplication.h

@@ -31,7 +31,7 @@
  * @brief Class @ref Magnum::Platform::WindowlessCglApplication, @ref Magnum::Platform::WindowlessCglContext, macro @ref MAGNUM_WINDOWLESSCGLAPPLICATION_MAIN()
  */
 
-#include <memory>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -295,7 +295,7 @@ class WindowlessCglApplication {
 
     private:
         WindowlessCglContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/Platform/WindowlessEglApplication.h

@@ -29,15 +29,15 @@
  * @brief Class @ref Magnum::Platform::WindowlessEglApplication, @ref Magnum::Platform::WindowlessEglContext, macro @ref MAGNUM_WINDOWLESSEGLAPPLICATION_MAIN()
  */
 
-#include <memory>
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
-#include <Corrade/Containers/EnumSet.h>
 /* undef Xlib nonsense to avoid conflicts */
 #undef Always
 #undef Complex
 #undef None
 #undef Status
+#include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/GL/OpenGL.h"
@@ -434,7 +434,7 @@ class WindowlessEglApplication {
 
     private:
         WindowlessEglContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/Platform/WindowlessGlxApplication.h

@@ -29,8 +29,8 @@
  * @brief Class @ref Magnum::Platform::WindowlessGlxApplication, @ref Magnum::Platform::WindowlessGlxContext, macro @ref MAGNUM_WINDOWLESSGLXAPPLICATION_MAIN()
  */
 
-#include <memory>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 /* Include our GL headers first to avoid conflicts */
 #include "Magnum/Magnum.h"
@@ -390,7 +390,7 @@ class WindowlessGlxApplication {
 
     private:
         WindowlessGlxContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/Platform/WindowlessIosApplication.h

@@ -29,8 +29,8 @@
  * @brief Class @ref Magnum::Platform::WindowlessIosApplication, @ref Magnum::Platform::WindowlessIosContext, macro @ref MAGNUM_WINDOWLESSIOSAPPLICATION_MAIN()
  */
 
-#include <memory>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -293,7 +293,7 @@ class WindowlessIosApplication {
 
     private:
         WindowlessIosContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/Platform/WindowlessWglApplication.h

@@ -29,13 +29,13 @@
  * @brief Class @ref Magnum::Platform::WindowlessWglApplication, @ref Magnum::Platform::WindowlessWglContext, macro @ref MAGNUM_WINDOWLESSWGLAPPLICATION_MAIN()
  */
 
-#include <memory>
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #define WIN32_LEAN_AND_MEAN 1
 #define VC_EXTRALEAN
 #endif
 #include <windows.h>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -388,7 +388,7 @@ class WindowlessWglApplication {
 
     private:
         WindowlessWglContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/Platform/WindowlessWindowsEglApplication.h

@@ -29,7 +29,6 @@
  * @brief Class @ref Magnum::Platform::WindowlessWindowsEglApplication, @ref Magnum::Platform::WindowlessWindowsEglContext, macro @ref MAGNUM_WINDOWLESSWINDOWSEGLAPPLICATION_MAIN()
  */
 
-#include <memory>
 #ifndef DOXYGEN_GENERATING_OUTPUT
 #define WIN32_LEAN_AND_MEAN 1
 #define VC_EXTRALEAN
@@ -38,6 +37,7 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include <Corrade/Containers/EnumSet.h>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Magnum.h"
 #include "Magnum/Tags.h"
@@ -359,7 +359,7 @@ class WindowlessWindowsEglApplication {
 
     private:
         WindowlessWindowsEglContext _glContext;
-        std::unique_ptr<Platform::GLContext> _context;
+        Containers::Pointer<Platform::GLContext> _context;
 };
 
 /** @hideinitializer

src/Magnum/SceneGraph/Test/ObjectTest.cpp

@@ -23,8 +23,8 @@
     DEALINGS IN THE SOFTWARE.
 */
 
-#include <memory>
 #include <sstream>
+#include <Corrade/Containers/Pointer.h>
 #include <Corrade/TestSuite/Tester.h>
 
 #include "Magnum/SceneGraph/MatrixTransformation3D.h"
@@ -94,14 +94,14 @@ ObjectTest::ObjectTest() {
 void ObjectTest::addFeature() {
     class MyFeature: public AbstractFeature3D {
         public:
-            explicit MyFeature(AbstractObject3D& object, Int&, std::unique_ptr<int>&&): AbstractFeature3D{object} {}
+            explicit MyFeature(AbstractObject3D& object, Int&, Containers::Pointer<int>&&): AbstractFeature3D{object} {}
     };
 
     Object3D o;
     CORRADE_VERIFY(o.features().isEmpty());
     /* Test perfect forwarding as well */
     int a = 0;
-    MyFeature& f = o.addFeature<MyFeature>(a, std::unique_ptr<int>{});
+    MyFeature& f = o.addFeature<MyFeature>(a, Containers::Pointer<int>{});
     CORRADE_VERIFY(!o.features().isEmpty());
     CORRADE_COMPARE(&f.object(), &o);
 }
@@ -139,14 +139,14 @@ void ObjectTest::parenting() {
 void ObjectTest::addChild() {
     class MyObject: public Object3D {
         public:
-            explicit MyObject(Int&, std::unique_ptr<int>&&, Object3D* parent = nullptr): Object3D{parent} {}
+            explicit MyObject(Int&, Containers::Pointer<int>&&, Object3D* parent = nullptr): Object3D{parent} {}
     };
 
     Object3D o;
     CORRADE_VERIFY(o.children().isEmpty());
     /* Test perfect forwarding as well */
     int a = 0;
-    MyObject& p = o.addChild<MyObject>(a, std::unique_ptr<int>{});
+    MyObject& p = o.addChild<MyObject>(a, Containers::Pointer<int>{});
     CORRADE_VERIFY(!o.children().isEmpty());
     CORRADE_COMPARE(p.parent(), &o);
 }

src/Magnum/Text/AbstractFont.cpp

@@ -165,7 +165,7 @@ void AbstractFont::doFillGlyphCache(GlyphCache&, const std::u32string&) {
     CORRADE_ASSERT(false, "Text::AbstractFont::fillGlyphCache(): feature advertised but not implemented", );
 }
 
-std::unique_ptr<GlyphCache> AbstractFont::createGlyphCache() {
+Containers::Pointer<GlyphCache> AbstractFont::createGlyphCache() {
     CORRADE_ASSERT(isOpened(),
         "Text::AbstractFont::createGlyphCache(): no font opened", nullptr);
     CORRADE_ASSERT(features() & Feature::PreparedGlyphCache,
@@ -174,12 +174,12 @@ std::unique_ptr<GlyphCache> AbstractFont::createGlyphCache() {
     return doCreateGlyphCache();
 }
 
-std::unique_ptr<GlyphCache> AbstractFont::doCreateGlyphCache() {
+Containers::Pointer<GlyphCache> AbstractFont::doCreateGlyphCache() {
     CORRADE_ASSERT(false, "Text::AbstractFont::createGlyphCache(): feature advertised but not implemented", nullptr);
     return nullptr;
 }
 
-std::unique_ptr<AbstractLayouter> AbstractFont::layout(const GlyphCache& cache, const Float size, const std::string& text) {
+Containers::Pointer<AbstractLayouter> AbstractFont::layout(const GlyphCache& cache, const Float size, const std::string& text) {
     CORRADE_ASSERT(isOpened(), "Text::AbstractFont::layout(): no font opened", nullptr);
 
     return doLayout(cache, size, text);

src/Magnum/Text/AbstractFont.h

@@ -29,7 +29,6 @@
  * @brief Class @ref Magnum::Text::AbstractFont, @ref Magnum::Text::AbstractLayouter
  */
 
-#include <memory>
 #include <string>
 #include <vector>
 #include <tuple>
@@ -251,7 +250,7 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin {
          * Other fonts support only partial glyph cache filling, see
          * @ref fillGlyphCache().
          */
-        std::unique_ptr<GlyphCache> createGlyphCache();
+        Containers::Pointer<GlyphCache> createGlyphCache();
 
         /**
          * @brief Layout the text using font's own layouter
@@ -263,7 +262,7 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin {
          * See @ref Renderer class for more advanced text layouting.
          * @see @ref fillGlyphCache(), @ref createGlyphCache()
          */
-        std::unique_ptr<AbstractLayouter> layout(const GlyphCache& cache, Float size, const std::string& text);
+        Containers::Pointer<AbstractLayouter> layout(const GlyphCache& cache, Float size, const std::string& text);
 
     protected:
         /**
@@ -349,10 +348,10 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin {
         virtual void doFillGlyphCache(GlyphCache& cache, const std::u32string& characters);
 
         /** @brief Implementation for @ref createGlyphCache() */
-        virtual std::unique_ptr<GlyphCache> doCreateGlyphCache();
+        virtual Containers::Pointer<GlyphCache> doCreateGlyphCache();
 
         /** @brief Implementation for @ref layout() */
-        virtual std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache& cache, Float size, const std::string& text) = 0;
+        virtual Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache& cache, Float size, const std::string& text) = 0;
 
     #ifdef DOXYGEN_GENERATING_OUTPUT
     private:

src/Magnum/Text/AbstractFontConverter.cpp

@@ -181,7 +181,7 @@ bool AbstractFontConverter::doExportGlyphCacheToFile(GlyphCache& cache, const st
     return true;
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::importGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::importGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const {
     CORRADE_ASSERT(features() >= (Feature::ImportGlyphCache|Feature::ConvertData),
         "Text::AbstractFontConverter::importGlyphCacheFromData(): feature not supported", nullptr);
     CORRADE_ASSERT(!data.empty(),
@@ -190,7 +190,7 @@ std::unique_ptr<GlyphCache> AbstractFontConverter::importGlyphCacheFromData(cons
     return doImportGlyphCacheFromData(data);
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const {
     CORRADE_ASSERT(!(features() & Feature::MultiFile),
         "Text::AbstractFontConverter::importGlyphCacheFromData(): feature advertised but not implemented", nullptr);
     CORRADE_ASSERT(data.size() == 1,
@@ -199,7 +199,7 @@ std::unique_ptr<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromData(co
     return doImportGlyphCacheFromSingleData(data[0].second);
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::importGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::importGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const {
     CORRADE_ASSERT(features() >= (Feature::ImportGlyphCache|Feature::ConvertData),
         "Text::AbstractFontConverter::importGlyphCacheFromSingleData(): feature not supported", nullptr);
     CORRADE_ASSERT(!(features() & Feature::MultiFile),
@@ -208,20 +208,20 @@ std::unique_ptr<GlyphCache> AbstractFontConverter::importGlyphCacheFromSingleDat
     return doImportGlyphCacheFromSingleData(data);
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromSingleData(Containers::ArrayView<const char>) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromSingleData(Containers::ArrayView<const char>) const {
     CORRADE_ASSERT(false,
         "Text::AbstractFontConverter::importGlyphCacheFromSingleData(): feature advertised but not implemented", nullptr);
     return nullptr;
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::importGlyphCacheFromFile(const std::string& filename) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::importGlyphCacheFromFile(const std::string& filename) const {
     CORRADE_ASSERT(features() & Feature::ImportGlyphCache,
         "Text::AbstractFontConverter::importGlyphCacheFromFile(): feature not supported", nullptr);
 
     return doImportGlyphCacheFromFile(filename);
 }
 
-std::unique_ptr<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromFile(const std::string& filename) const {
+Containers::Pointer<GlyphCache> AbstractFontConverter::doImportGlyphCacheFromFile(const std::string& filename) const {
     CORRADE_ASSERT(features() & Feature::ConvertData && !(features() & Feature::MultiFile),
         "Text::AbstractFontConverter::importGlyphCacheFromFile(): not implemented", nullptr);
 

src/Magnum/Text/AbstractFontConverter.h

@@ -29,7 +29,6 @@
  * @brief Class @ref Magnum::Text::AbstractFontConverter
  */
 
-#include <memory>
 #include <vector>
 #include <Corrade/Containers/EnumSet.h>
 #include <Corrade/PluginManager/AbstractPlugin.h>
@@ -262,7 +261,7 @@ class MAGNUM_TEXT_EXPORT AbstractFontConverter: public PluginManager::AbstractPl
          * @see @ref features(), @ref importGlyphCacheFromFile(),
          *      @ref exportGlyphCacheToData()
          */
-        std::unique_ptr<GlyphCache> importGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const;
+        Containers::Pointer<GlyphCache> importGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const;
 
         /**
          * @brief Import glyph cache from single raw data
@@ -274,7 +273,7 @@ class MAGNUM_TEXT_EXPORT AbstractFontConverter: public PluginManager::AbstractPl
          * @see @ref features(), @ref importGlyphCacheFromFile(),
          *      @ref exportFontToSingleData()
          */
-        std::unique_ptr<GlyphCache> importGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const;
+        Containers::Pointer<GlyphCache> importGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const;
 
         /**
          * @brief Import glyph cache from file
@@ -287,7 +286,7 @@ class MAGNUM_TEXT_EXPORT AbstractFontConverter: public PluginManager::AbstractPl
          * @see @ref features(), @ref importGlyphCacheFromData(),
          *      @ref exportGlyphCacheToFile()
          */
-        std::unique_ptr<GlyphCache> importGlyphCacheFromFile(const std::string& filename) const;
+        Containers::Pointer<GlyphCache> importGlyphCacheFromFile(const std::string& filename) const;
 
     private:
         /** @brief Implementation for @ref features() */
@@ -339,10 +338,10 @@ class MAGNUM_TEXT_EXPORT AbstractFontConverter: public PluginManager::AbstractPl
          * If the plugin doesn't have @ref Feature::MultiFile, default
          * implementation calls @ref doImportGlyphCacheFromSingleData().
          */
-        virtual std::unique_ptr<GlyphCache> doImportGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const;
+        virtual Containers::Pointer<GlyphCache> doImportGlyphCacheFromData(const std::vector<std::pair<std::string, Containers::ArrayView<const char>>>& data) const;
 
         /** @brief Implementation for @ref importGlyphCacheFromSingleData() */
-        virtual std::unique_ptr<GlyphCache> doImportGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const;
+        virtual Containers::Pointer<GlyphCache> doImportGlyphCacheFromSingleData(Containers::ArrayView<const char> data) const;
 
         /**
          * @brief Implementation for @ref importGlyphCacheFromFile()
@@ -351,7 +350,7 @@ class MAGNUM_TEXT_EXPORT AbstractFontConverter: public PluginManager::AbstractPl
          * have @ref Feature::MultiFile, default implementation opens the file
          * and calls @ref doImportGlyphCacheFromSingleData() with its contents.
          */
-        virtual std::unique_ptr<GlyphCache> doImportGlyphCacheFromFile(const std::string& filename) const;
+        virtual Containers::Pointer<GlyphCache> doImportGlyphCacheFromFile(const std::string& filename) const;
 };
 
 CORRADE_ENUMSET_OPERATORS(AbstractFontConverter::Features)

src/Magnum/Text/Renderer.cpp

@@ -95,7 +95,7 @@ std::tuple<std::vector<Vertex>, Range2D> renderVerticesInternal(AbstractFont& fo
         line.assign(text, prevPos, pos-prevPos);
 
         /* Layout the line */
-        const auto layouter = font.layout(cache, size, line);
+        Containers::Pointer<AbstractLayouter> layouter = font.layout(cache, size, line);
 
         /* Verify that we don't reallocate anything. The only problem might
            arise when the layouter decides to compose one character from more

src/Magnum/Text/Test/AbstractFontConverterTest.cpp

@@ -198,9 +198,9 @@ class SingleGlyphCacheDataImporter: public Text::AbstractFontConverter {
     private:
         Features doFeatures() const override { return Feature::ConvertData|Feature::ImportGlyphCache; }
 
-        std::unique_ptr<GlyphCache> doImportGlyphCacheFromSingleData(const Containers::ArrayView<const char> data) const override {
+        Containers::Pointer<GlyphCache> doImportGlyphCacheFromSingleData(const Containers::ArrayView<const char> data) const override {
             if(data.size() == 1 && data[0] == '\xa5')
-                return std::unique_ptr<GlyphCache>(reinterpret_cast<GlyphCache*>(0xdeadbeef));
+                return Containers::Pointer<GlyphCache>(reinterpret_cast<GlyphCache*>(0xdeadbeef));
             return nullptr;
         }
 };
@@ -209,7 +209,7 @@ void AbstractFontConverterTest::importGlyphCacheFromSingleData() {
     /* doImportFromData() should call doImportFromSingleData() */
     SingleGlyphCacheDataImporter importer;
     const char data[] = {'\xa5'};
-    std::unique_ptr<GlyphCache> cache = importer.importGlyphCacheFromData({{{}, data}});
+    Containers::Pointer<GlyphCache> cache = importer.importGlyphCacheFromData({{{}, data}});
     CORRADE_COMPARE(cache.get(), reinterpret_cast<GlyphCache*>(0xdeadbeef));
 
     /* The pointer is invalid, avoid deletion */
@@ -219,7 +219,7 @@ void AbstractFontConverterTest::importGlyphCacheFromSingleData() {
 void AbstractFontConverterTest::importGlyphCacheFromFile() {
     /* doImportFromFile() should call doImportFromSingleData() */
     SingleGlyphCacheDataImporter importer;
-    std::unique_ptr<GlyphCache> cache = importer.importGlyphCacheFromFile(Utility::Directory::join(TEXT_TEST_DIR, "data.bin"));
+    Containers::Pointer<GlyphCache> cache = importer.importGlyphCacheFromFile(Utility::Directory::join(TEXT_TEST_DIR, "data.bin"));
     CORRADE_COMPARE(cache.get(), reinterpret_cast<GlyphCache*>(0xdeadbeef));
 
     /* The pointer is invalid, avoid deletion */

src/Magnum/Text/Test/AbstractFontTest.cpp

@@ -63,7 +63,7 @@ class SingleDataFont: public Text::AbstractFont {
 
         Vector2 doGlyphAdvance(UnsignedInt) override { return {}; }
 
-        std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string&) override {
+        Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string&) override {
             return nullptr;
         }
 

src/Magnum/Text/Test/RendererGLTest.cpp

@@ -79,8 +79,8 @@ class TestFont: public Text::AbstractFont {
     UnsignedInt doGlyphId(char32_t) override { return 0; }
     Vector2 doGlyphAdvance(UnsignedInt) override { return {}; }
 
-    std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache&, const Float size, const std::string& text) override {
+    Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache&, const Float size, const std::string& text) override {
-        return std::unique_ptr<AbstractLayouter>(new TestLayouter(size, text.size()));
+        return Containers::Pointer<AbstractLayouter>(new TestLayouter(size, text.size()));
     }
 };
 
@@ -353,8 +353,8 @@ void RendererGLTest::multiline() {
             UnsignedInt doGlyphId(char32_t) override { return 0; }
             Vector2 doGlyphAdvance(UnsignedInt) override { return {}; }
 
-            std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string& text) override {
+            Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string& text) override {
-                return std::unique_ptr<AbstractLayouter>(new Layouter(text.size()));
+                return Containers::Pointer<AbstractLayouter>(new Layouter(text.size()));
             }
 
             bool _opened;

src/Magnum/Text/fontconverter.cpp

@@ -164,14 +164,14 @@ int FontConverter::exec() {
     PluginManager::Manager<Text::AbstractFont> fontManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Text::AbstractFont::pluginSearchPaths()[0])};
-    std::unique_ptr<Text::AbstractFont> font = fontManager.loadAndInstantiate(args.value("font"));
+    Containers::Pointer<Text::AbstractFont> font = fontManager.loadAndInstantiate(args.value("font"));
     if(!font) return 1;
 
     /* Load font converter */
     PluginManager::Manager<Text::AbstractFontConverter> converterManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Text::AbstractFontConverter::pluginSearchPaths()[0])};
-    std::unique_ptr<Text::AbstractFontConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
+    Containers::Pointer<Text::AbstractFontConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
     if(!converter) return 2;
 
     /* Open font */
@@ -181,7 +181,7 @@ int FontConverter::exec() {
     }
 
     /* Create distance field glyph cache if radius is specified */
-    std::unique_ptr<Text::GlyphCache> cache;
+    Containers::Pointer<Text::GlyphCache> cache;
     if(!args.value<Vector2i>("output-size").isZero()) {
         Debug() << "Populating distance field glyph cache...";
 

src/Magnum/TextureTools/DistanceField.h

@@ -29,11 +29,11 @@
  * @brief Function @ref Magnum::TextureTools::distanceField()
  */
 
-#include <memory>
-
 #include "Magnum/configure.h"
 
 #ifdef MAGNUM_TARGET_GL
+#include <Corrade/Containers/Pointer.h>
+
 #include "Magnum/Magnum.h"
 #include "Magnum/GL/GL.h"
 #ifndef MAGNUM_TARGET_GLES
@@ -126,7 +126,7 @@ class MAGNUM_TEXTURETOOLS_EXPORT DistanceField {
 
     private:
         struct State;
-        std::unique_ptr<State> _state;
+        Containers::Pointer<State> _state;
 };
 
 #ifdef MAGNUM_BUILD_DEPRECATED

src/Magnum/TextureTools/Test/DistanceFieldGLTest.cpp

@@ -91,7 +91,7 @@ DistanceFieldGLTest::DistanceFieldGLTest() {
 }
 
 void DistanceFieldGLTest::test() {
-    std::unique_ptr<Trade::AbstractImporter> importer;
+    Containers::Pointer<Trade::AbstractImporter> importer;
     if(!(importer = _manager.loadAndInstantiate("TgaImporter")))
         CORRADE_SKIP("TgaImporter plugin not found.");
 
@@ -207,7 +207,7 @@ void DistanceFieldGLTest::test() {
 
 #ifndef MAGNUM_TARGET_WEBGL
 void DistanceFieldGLTest::benchmark() {
-    std::unique_ptr<Trade::AbstractImporter> importer;
+    Containers::Pointer<Trade::AbstractImporter> importer;
     if(!(importer = _manager.loadAndInstantiate("TgaImporter")))
         CORRADE_SKIP("TgaImporter plugin not found.");
 

src/Magnum/TextureTools/distancefieldconverter.cpp

@@ -158,14 +158,14 @@ int DistanceFieldConverter::exec() {
     PluginManager::Manager<Trade::AbstractImporter> importerManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Trade::AbstractImporter::pluginSearchPaths()[0])};
-    std::unique_ptr<Trade::AbstractImporter> importer = importerManager.loadAndInstantiate(args.value("importer"));
+    Containers::Pointer<Trade::AbstractImporter> importer = importerManager.loadAndInstantiate(args.value("importer"));
     if(!importer) return 1;
 
     /* Load converter plugin */
     PluginManager::Manager<Trade::AbstractImageConverter> converterManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Trade::AbstractImageConverter::pluginSearchPaths()[0])};
-    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
+    Containers::Pointer<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
     if(!converter) return 2;
 
     /* Open input file */

src/Magnum/Trade/AbstractImporter.cpp

@@ -336,13 +336,13 @@ std::string AbstractImporter::object2DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doObject2DName(UnsignedInt) { return {}; }
 
-std::unique_ptr<ObjectData2D> AbstractImporter::object2D(const UnsignedInt id) {
+Containers::Pointer<ObjectData2D> AbstractImporter::object2D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::object2D(): no file opened", {});
     CORRADE_ASSERT(id < doObject2DCount(), "Trade::AbstractImporter::object2D(): index out of range", {});
     return doObject2D(id);
 }
 
-std::unique_ptr<ObjectData2D> AbstractImporter::doObject2D(UnsignedInt) {
+Containers::Pointer<ObjectData2D> AbstractImporter::doObject2D(UnsignedInt) {
     CORRADE_ASSERT(false, "Trade::AbstractImporter::object2D(): not implemented", {});
 }
 
@@ -368,13 +368,13 @@ std::string AbstractImporter::object3DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doObject3DName(UnsignedInt) { return {}; }
 
-std::unique_ptr<ObjectData3D> AbstractImporter::object3D(const UnsignedInt id) {
+Containers::Pointer<ObjectData3D> AbstractImporter::object3D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::object3D(): no file opened", {});
     CORRADE_ASSERT(id < doObject3DCount(), "Trade::AbstractImporter::object3D(): index out of range", {});
     return doObject3D(id);
 }
 
-std::unique_ptr<ObjectData3D> AbstractImporter::doObject3D(UnsignedInt) {
+Containers::Pointer<ObjectData3D> AbstractImporter::doObject3D(UnsignedInt) {
     CORRADE_ASSERT(false, "Trade::AbstractImporter::object3D(): not implemented", {});
 }
 
@@ -464,13 +464,13 @@ std::string AbstractImporter::materialName(const UnsignedInt id) {
 
 std::string AbstractImporter::doMaterialName(UnsignedInt) { return {}; }
 
-std::unique_ptr<AbstractMaterialData> AbstractImporter::material(const UnsignedInt id) {
+Containers::Pointer<AbstractMaterialData> AbstractImporter::material(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::material(): no file opened", {});
     CORRADE_ASSERT(id < doMaterialCount(), "Trade::AbstractImporter::material(): index out of range", {});
     return doMaterial(id);
 }
 
-std::unique_ptr<AbstractMaterialData> AbstractImporter::doMaterial(UnsignedInt) {
+Containers::Pointer<AbstractMaterialData> AbstractImporter::doMaterial(UnsignedInt) {
     CORRADE_ASSERT(false, "Trade::AbstractImporter::material(): not implemented", {});
 }
 

src/Magnum/Trade/AbstractImporter.h

@@ -29,7 +29,6 @@
  * @brief Class @ref Magnum::Trade::AbstractImporter
  */
 
-#include <memory>
 #include <Corrade/Containers/EnumSet.h>
 #include <Corrade/PluginManager/AbstractManagingPlugin.h>
 
@@ -168,7 +167,7 @@ about concrete types returned and accepted by these functions.
 
 @subsection Trade-AbstractImporter-usage-casting Polymorphic imported data types
 
-Some data access functions return @ref std::unique_ptr instead of
+Some data access functions return @ref Corrade::Containers::Pointer instead of
 @ref Corrade::Containers::Optional because the result might be a particular
 subclass of given type. Those functions are @ref material(), @ref object2D()
 and @ref object3D(). You can cast the abstract base to a concrete type
@@ -176,8 +175,9 @@ depending on its reported type, for example:
 
 @snippet MagnumTrade.cpp AbstractImporter-usage-cast
 
-Another option is making use of the @ref std::static_pointer_cast() family of utilities, but note that in that case your @ref std::unique_ptr will be *moved
+Another option is making use of the @ref Containers::pointerCast() utility, but
-into* a @ref std::shared_ptr instance and that might not be desirable.
+note that in that case the original @ref Corrade::Containers::Pointer will be
+* *moved into* a new instance and that might not be desirable.
 
 @section Trade-AbstractImporter-subclassing Subclassing
 
@@ -581,7 +581,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
          *
          * Returns given object or @cpp nullptr @ce if importing failed.
          */
-        std::unique_ptr<ObjectData2D> object2D(UnsignedInt id);
+        Containers::Pointer<ObjectData2D> object2D(UnsignedInt id);
 
         /** @brief Three-dimensional object count */
         UnsignedInt object3DCount() const;
@@ -608,7 +608,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
          *
          * Returns given object or @cpp nullptr @ce if importing failed.
          */
-        std::unique_ptr<ObjectData3D> object3D(UnsignedInt id);
+        Containers::Pointer<ObjectData3D> object3D(UnsignedInt id);
 
         /** @brief Two-dimensional mesh count */
         UnsignedInt mesh2DCount() const;
@@ -689,7 +689,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
          *
          * Returns given material or @cpp nullptr @ce if importing failed.
          */
-        std::unique_ptr<AbstractMaterialData> material(UnsignedInt id);
+        Containers::Pointer<AbstractMaterialData> material(UnsignedInt id);
 
         /** @brief Texture count */
         UnsignedInt textureCount() const;
@@ -987,7 +987,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
         virtual std::string doObject2DName(UnsignedInt id);
 
         /** @brief Implementation for @ref object2D() */
-        virtual std::unique_ptr<ObjectData2D> doObject2D(UnsignedInt id);
+        virtual Containers::Pointer<ObjectData2D> doObject2D(UnsignedInt id);
 
         /**
          * @brief Implementation for @ref object3DCount()
@@ -1011,7 +1011,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
         virtual std::string doObject3DName(UnsignedInt id);
 
         /** @brief Implementation for @ref object3D() */
-        virtual std::unique_ptr<ObjectData3D> doObject3D(UnsignedInt id);
+        virtual Containers::Pointer<ObjectData3D> doObject3D(UnsignedInt id);
 
         /**
          * @brief Implementation for @ref mesh2DCount()
@@ -1083,7 +1083,7 @@ class MAGNUM_TRADE_EXPORT AbstractImporter: public PluginManager::AbstractManagi
         virtual std::string doMaterialName(UnsignedInt id);
 
         /** @brief Implementation for @ref material() */
-        virtual std::unique_ptr<AbstractMaterialData> doMaterial(UnsignedInt id);
+        virtual Containers::Pointer<AbstractMaterialData> doMaterial(UnsignedInt id);
 
         /**
          * @brief Implementation for @ref textureCount()

src/Magnum/Trade/Test/AbstractImporterTest.cpp

@@ -1649,8 +1649,8 @@ void AbstractImporterTest::object2D() {
             if(id == 7) return "eighth";
             else return {};
         }
-        std::unique_ptr<ObjectData2D> doObject2D(UnsignedInt id) override {
+        Containers::Pointer<ObjectData2D> doObject2D(UnsignedInt id) override {
-            if(id == 7) return std::unique_ptr<ObjectData2D>{new ObjectData2D{{}, {}, &state}};
+            if(id == 7) return Containers::pointer(new ObjectData2D{{}, {}, &state});
             else return {};
         }
     };
@@ -1825,8 +1825,8 @@ void AbstractImporterTest::object3D() {
             if(id == 7) return "eighth";
             else return {};
         }
-        std::unique_ptr<ObjectData3D> doObject3D(UnsignedInt id) override {
+        Containers::Pointer<ObjectData3D> doObject3D(UnsignedInt id) override {
-            if(id == 7) return std::unique_ptr<ObjectData3D>{new ObjectData3D{{}, {}, &state}};
+            if(id == 7) return Containers::pointer(new ObjectData3D{{}, {}, &state});
             else return {};
         }
     };
@@ -2353,8 +2353,8 @@ void AbstractImporterTest::material() {
             if(id == 7) return "eighth";
             else return {};
         }
-        std::unique_ptr<AbstractMaterialData> doMaterial(UnsignedInt id) override {
+        Containers::Pointer<AbstractMaterialData> doMaterial(UnsignedInt id) override {
-            if(id == 7) return std::unique_ptr<PhongMaterialData>{new PhongMaterialData{{}, {}, {}, {}, &state}};
+            if(id == 7) return Containers::pointer(new PhongMaterialData{{}, {}, {}, {}, &state});
             else return {};
         }
     };

src/Magnum/Trade/imageconverter.cpp

@@ -101,14 +101,14 @@ int main(int argc, char** argv) {
     PluginManager::Manager<Trade::AbstractImporter> importerManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Trade::AbstractImporter::pluginSearchPaths()[0])};
-    std::unique_ptr<Trade::AbstractImporter> importer = importerManager.loadAndInstantiate(args.value("importer"));
+    Containers::Pointer<Trade::AbstractImporter> importer = importerManager.loadAndInstantiate(args.value("importer"));
     if(!importer) return 1;
 
     /* Load converter plugin */
     PluginManager::Manager<Trade::AbstractImageConverter> converterManager{
         args.value("plugin-dir").empty() ? std::string{} :
         Utility::Directory::join(args.value("plugin-dir"), Trade::AbstractImageConverter::pluginSearchPaths()[0])};
-    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
+    Containers::Pointer<Trade::AbstractImageConverter> converter = converterManager.loadAndInstantiate(args.value("converter"));
     if(!converter) return 2;
 
     /* Open input file */

src/MagnumPlugins/AnyAudioImporter/AnyImporter.cpp

@@ -68,7 +68,7 @@ void AnyImporter::doOpenFile(const std::string& filename) {
 
     /* Try to open the file (error output should be printed by the plugin
        itself) */
-    std::unique_ptr<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
+    Containers::Pointer<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
     if(!importer->openFile(filename)) return;
 
     /* Success, save the instance */

src/MagnumPlugins/AnyAudioImporter/AnyImporter.h

@@ -29,7 +29,7 @@
  * @brief Class @ref Magnum::Audio::AnyImporter
  */
 
-#include <memory>
+#include <Corrade/Containers/Pointer.h>
 
 #include "Magnum/Audio/AbstractImporter.h"
 #include "MagnumPlugins/AnyAudioImporter/configure.h"
@@ -98,7 +98,7 @@ class MAGNUM_ANYAUDIOIMPORTER_EXPORT AnyImporter: public AbstractImporter {
         MAGNUM_ANYAUDIOIMPORTER_LOCAL UnsignedInt doFrequency() const override;
         MAGNUM_ANYAUDIOIMPORTER_LOCAL Containers::Array<char> doData() override;
 
-        std::unique_ptr<AbstractImporter> _in;
+        Containers::Pointer<AbstractImporter> _in;
 };
 
 }}

src/MagnumPlugins/AnyAudioImporter/Test/AnyAudioImporterTest.cpp

@@ -64,7 +64,7 @@ void AnyImporterTest::wav() {
     if(!(_manager.loadState("WavAudioImporter") & PluginManager::LoadState::Loaded))
         CORRADE_SKIP("WavAudioImporter plugin not enabled, cannot test");
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
     CORRADE_VERIFY(importer->openFile(WAV_FILE));
 
     /* Check only parameters, as it is good enough proof that it is working */
@@ -76,7 +76,7 @@ void AnyImporterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyAudioImporter");
     CORRADE_VERIFY(!importer->openFile("sound.mid"));
 
     CORRADE_COMPARE(output.str(), "Audio::AnyImporter::openFile(): cannot determine type of file sound.mid\n");

src/MagnumPlugins/AnyImageConverter/Test/AnyImageConverterTest.cpp

@@ -84,7 +84,7 @@ void AnyImageConverterTest::tga() {
         CORRADE_VERIFY(Utility::Directory::rm(filename));
 
     /* Just test that the exported file exists */
-    std::unique_ptr<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
+    Containers::Pointer<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
     CORRADE_VERIFY(converter->exportToFile(Image, filename));
     CORRADE_VERIFY(Utility::Directory::fileExists(filename));
 }
@@ -93,7 +93,7 @@ void AnyImageConverterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    std::unique_ptr<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
+    Containers::Pointer<AbstractImageConverter> converter = _manager.instantiate("AnyImageConverter");
     CORRADE_VERIFY(!converter->exportToFile(Image, "image.xcf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageConverter::exportToFile(): cannot determine type of file image.xcf\n");

src/MagnumPlugins/AnyImageImporter/AnyImageImporter.cpp

@@ -113,7 +113,7 @@ void AnyImageImporter::doOpenFile(const std::string& filename) {
 
     /* Try to open the file (error output should be printed by the plugin
        itself) */
-    std::unique_ptr<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
+    Containers::Pointer<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
     if(!importer->openFile(filename)) return;
 
     /* Success, save the instance */
@@ -181,7 +181,7 @@ void AnyImageImporter::doOpenData(Containers::ArrayView<const char> data) {
 
     /* Try to open the file (error output should be printed by the plugin
        itself) */
-    std::unique_ptr<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
+    Containers::Pointer<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
     if(!importer->openData(data)) return;
 
     /* Success, save the instance */

src/MagnumPlugins/AnyImageImporter/AnyImageImporter.h

@@ -123,7 +123,7 @@ class MAGNUM_ANYIMAGEIMPORTER_EXPORT AnyImageImporter: public AbstractImporter {
         MAGNUM_ANYIMAGEIMPORTER_LOCAL UnsignedInt doImage2DCount() const override;
         MAGNUM_ANYIMAGEIMPORTER_LOCAL Containers::Optional<ImageData2D> doImage2D(UnsignedInt id) override;
 
-        std::unique_ptr<AbstractImporter> _in;
+        Containers::Pointer<AbstractImporter> _in;
 };
 
 }}

src/MagnumPlugins/AnyImageImporter/Test/AnyImageImporterTest.cpp

@@ -119,7 +119,7 @@ void AnyImageImporterTest::load() {
     if(!(_manager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
         CORRADE_SKIP("TgaImporter plugin not enabled, cannot test");
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
 
     Containers::Array<char> storage;
     importer->setFileCallback(data.callback, storage);
@@ -139,7 +139,7 @@ void AnyImageImporterTest::detect() {
     auto&& data = DetectData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
 
     Containers::Array<char> storage;
     importer->setFileCallback(data.callback, storage);
@@ -161,7 +161,7 @@ void AnyImageImporterTest::unknownExtension() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
     CORRADE_VERIFY(!importer->openFile("image.xcf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageImporter::openFile(): cannot determine type of file image.xcf\n");
@@ -173,7 +173,7 @@ void AnyImageImporterTest::unknownSignature() {
 
     constexpr const char data[]{ 0x25, 0x3a };
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
     CORRADE_VERIFY(!importer->openData(data));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageImporter::openData(): cannot determine type from signature 0x253a0000\n");
@@ -183,7 +183,7 @@ void AnyImageImporterTest::emptyData() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnyImageImporter");
     CORRADE_VERIFY(!importer->openData(nullptr));
 
     CORRADE_COMPARE(output.str(), "Trade::AnyImageImporter::openData(): file is empty\n");

src/MagnumPlugins/AnySceneImporter/AnySceneImporter.cpp

@@ -132,7 +132,7 @@ void AnySceneImporter::doOpenFile(const std::string& filename) {
 
     /* Try to open the file (error output should be printed by the plugin
        itself) */
-    std::unique_ptr<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
+    Containers::Pointer<AbstractImporter> importer = static_cast<PluginManager::Manager<AbstractImporter>*>(manager())->instantiate(plugin);
     if(!importer->openFile(filename)) return;
 
     /* Success, save the instance */
@@ -164,12 +164,12 @@ Containers::Optional<CameraData> AnySceneImporter::doCamera(const UnsignedInt id
 UnsignedInt AnySceneImporter::doObject2DCount() const { return _in->object2DCount(); }
 Int AnySceneImporter::doObject2DForName(const std::string& name) { return _in->object2DForName(name); }
 std::string AnySceneImporter::doObject2DName(const UnsignedInt id) { return _in->object2DName(id); }
-std::unique_ptr<ObjectData2D> AnySceneImporter::doObject2D(const UnsignedInt id) { return _in->object2D(id); }
+Containers::Pointer<ObjectData2D> AnySceneImporter::doObject2D(const UnsignedInt id) { return _in->object2D(id); }
 
 UnsignedInt AnySceneImporter::doObject3DCount() const { return _in->object3DCount(); }
 Int AnySceneImporter::doObject3DForName(const std::string& name) { return _in->object3DForName(name); }
 std::string AnySceneImporter::doObject3DName(const UnsignedInt id) { return _in->object3DName(id); }
-std::unique_ptr<ObjectData3D> AnySceneImporter::doObject3D(const UnsignedInt id) { return _in->object3D(id); }
+Containers::Pointer<ObjectData3D> AnySceneImporter::doObject3D(const UnsignedInt id) { return _in->object3D(id); }
 
 UnsignedInt AnySceneImporter::doMesh2DCount() const { return _in->mesh2DCount(); }
 Int AnySceneImporter::doMesh2DForName(const std::string& name) { return _in->mesh2DForName(name); }
@@ -184,7 +184,7 @@ Containers::Optional<MeshData3D> AnySceneImporter::doMesh3D(const UnsignedInt id
 UnsignedInt AnySceneImporter::doMaterialCount() const { return _in->materialCount(); }
 Int AnySceneImporter::doMaterialForName(const std::string& name) { return _in->materialForName(name); }
 std::string AnySceneImporter::doMaterialName(const UnsignedInt id) { return _in->materialName(id); }
-std::unique_ptr<AbstractMaterialData> AnySceneImporter::doMaterial(const UnsignedInt id) { return _in->material(id); }
+Containers::Pointer<AbstractMaterialData> AnySceneImporter::doMaterial(const UnsignedInt id) { return _in->material(id); }
 
 UnsignedInt AnySceneImporter::doTextureCount() const { return _in->textureCount(); }
 Int AnySceneImporter::doTextureForName(const std::string& name) { return _in->textureForName(name); }

src/MagnumPlugins/AnySceneImporter/AnySceneImporter.h

@@ -149,12 +149,12 @@ class MAGNUM_ANYSCENEIMPORTER_EXPORT AnySceneImporter: public AbstractImporter {
         MAGNUM_ANYSCENEIMPORTER_LOCAL UnsignedInt doObject2DCount() const override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Int doObject2DForName(const std::string& name) override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL std::string doObject2DName(UnsignedInt id) override;
-        MAGNUM_ANYSCENEIMPORTER_LOCAL std::unique_ptr<ObjectData2D> doObject2D(UnsignedInt id) override;
+        MAGNUM_ANYSCENEIMPORTER_LOCAL Containers::Pointer<ObjectData2D> doObject2D(UnsignedInt id) override;
 
         MAGNUM_ANYSCENEIMPORTER_LOCAL UnsignedInt doObject3DCount() const override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Int doObject3DForName(const std::string& name) override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL std::string doObject3DName(UnsignedInt id) override;
-        MAGNUM_ANYSCENEIMPORTER_LOCAL std::unique_ptr<ObjectData3D> doObject3D(UnsignedInt id) override;
+        MAGNUM_ANYSCENEIMPORTER_LOCAL Containers::Pointer<ObjectData3D> doObject3D(UnsignedInt id) override;
 
         MAGNUM_ANYSCENEIMPORTER_LOCAL UnsignedInt doMesh2DCount() const override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Int doMesh2DForName(const std::string& name) override;
@@ -169,7 +169,7 @@ class MAGNUM_ANYSCENEIMPORTER_EXPORT AnySceneImporter: public AbstractImporter {
         MAGNUM_ANYSCENEIMPORTER_LOCAL UnsignedInt doMaterialCount() const override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Int doMaterialForName(const std::string& name) override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL std::string doMaterialName(UnsignedInt id) override;
-        MAGNUM_ANYSCENEIMPORTER_LOCAL std::unique_ptr<AbstractMaterialData> doMaterial(UnsignedInt id) override;
+        MAGNUM_ANYSCENEIMPORTER_LOCAL Containers::Pointer<AbstractMaterialData> doMaterial(UnsignedInt id) override;
 
         MAGNUM_ANYSCENEIMPORTER_LOCAL UnsignedInt doTextureCount() const override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Int doTextureForName(const std::string& name) override;
@@ -191,7 +191,7 @@ class MAGNUM_ANYSCENEIMPORTER_EXPORT AnySceneImporter: public AbstractImporter {
         MAGNUM_ANYSCENEIMPORTER_LOCAL std::string doImage3DName(UnsignedInt id) override;
         MAGNUM_ANYSCENEIMPORTER_LOCAL Containers::Optional<ImageData3D> doImage3D(UnsignedInt id) override;
 
-        std::unique_ptr<AbstractImporter> _in;
+        Containers::Pointer<AbstractImporter> _in;
 };
 
 }}

src/MagnumPlugins/AnySceneImporter/Test/AnySceneImporterTest.cpp

@@ -67,7 +67,7 @@ void AnySceneImporterTest::obj() {
     if(!(_manager.loadState("ObjImporter") & PluginManager::LoadState::Loaded))
         CORRADE_SKIP("ObjImporter plugin not enabled, cannot test");
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
     CORRADE_VERIFY(importer->openFile(OBJ_FILE));
 
     /* Check only size, as it is good enough proof that it is working */
@@ -80,7 +80,7 @@ void AnySceneImporterTest::unknown() {
     std::ostringstream output;
     Error redirectError{&output};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("AnySceneImporter");
     CORRADE_VERIFY(!importer->openFile("mesh.wtf"));
 
     CORRADE_COMPARE(output.str(), "Trade::AnySceneImporter::openFile(): cannot determine type of file mesh.wtf\n");

src/MagnumPlugins/MagnumFont/MagnumFont.cpp

@@ -184,9 +184,9 @@ Vector2 MagnumFont::doGlyphAdvance(const UnsignedInt glyph) {
     return glyph < _opened->glyphAdvance.size() ? _opened->glyphAdvance[glyph] : Vector2();
 }
 
-std::unique_ptr<GlyphCache> MagnumFont::doCreateGlyphCache() {
+Containers::Pointer<GlyphCache> MagnumFont::doCreateGlyphCache() {
     /* Set cache image */
-    std::unique_ptr<GlyphCache> cache(new Text::GlyphCache(
+    Containers::Pointer<GlyphCache> cache(new Text::GlyphCache(
         _opened->conf.value<Vector2i>("originalImageSize"),
         _opened->image.size(),
         _opened->conf.value<Vector2i>("padding")));
@@ -200,7 +200,7 @@ std::unique_ptr<GlyphCache> MagnumFont::doCreateGlyphCache() {
     return cache;
 }
 
-std::unique_ptr<AbstractLayouter> MagnumFont::doLayout(const GlyphCache& cache, Float size, const std::string& text) {
+Containers::Pointer<AbstractLayouter> MagnumFont::doLayout(const GlyphCache& cache, Float size, const std::string& text) {
     /* Get glyph codes from characters */
     std::vector<UnsignedInt> glyphs;
     glyphs.reserve(text.size());
@@ -211,7 +211,7 @@ std::unique_ptr<AbstractLayouter> MagnumFont::doLayout(const GlyphCache& cache,
         glyphs.push_back(it == _opened->glyphId.end() ? 0 : it->second);
     }
 
-    return std::unique_ptr<MagnumFontLayouter>(new MagnumFontLayouter(_opened->glyphAdvance, cache, this->size(), size, std::move(glyphs)));
+    return Containers::Pointer<MagnumFontLayouter>(new MagnumFontLayouter(_opened->glyphAdvance, cache, this->size(), size, std::move(glyphs)));
 }
 
 namespace {

src/MagnumPlugins/MagnumFont/MagnumFont.h

@@ -143,8 +143,8 @@ class MAGNUM_MAGNUMFONT_EXPORT MagnumFont: public AbstractFont {
 
         MAGNUM_MAGNUMFONT_LOCAL UnsignedInt doGlyphId(char32_t character) override;
         MAGNUM_MAGNUMFONT_LOCAL Vector2 doGlyphAdvance(UnsignedInt glyph) override;
-        MAGNUM_MAGNUMFONT_LOCAL std::unique_ptr<GlyphCache> doCreateGlyphCache() override;
+        MAGNUM_MAGNUMFONT_LOCAL Containers::Pointer<GlyphCache> doCreateGlyphCache() override;
-        MAGNUM_MAGNUMFONT_LOCAL std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache& cache, Float size, const std::string& text) override;
+        MAGNUM_MAGNUMFONT_LOCAL Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache& cache, Float size, const std::string& text) override;
 
         MAGNUM_MAGNUMFONT_LOCAL Metrics openInternal(Utility::Configuration&& conf, Trade::ImageData2D&& image);
 

src/MagnumPlugins/MagnumFont/Test/MagnumFontGLTest.cpp

@@ -63,7 +63,7 @@ MagnumFontGLTest::MagnumFontGLTest() {
 }
 
 void MagnumFontGLTest::nonexistent() {
-    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+    Containers::Pointer<AbstractFont> font = _fontManager.instantiate("MagnumFont");
 
     std::ostringstream out;
     Error redirectError{&out};
@@ -72,7 +72,7 @@ void MagnumFontGLTest::nonexistent() {
 }
 
 void MagnumFontGLTest::properties() {
-    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+    Containers::Pointer<AbstractFont> font = _fontManager.instantiate("MagnumFont");
 
     CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
     CORRADE_COMPARE(font->size(), 16.0f);
@@ -83,7 +83,7 @@ void MagnumFontGLTest::properties() {
 }
 
 void MagnumFontGLTest::layout() {
-    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+    Containers::Pointer<AbstractFont> font = _fontManager.instantiate("MagnumFont");
 
     CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
 
@@ -127,12 +127,12 @@ void MagnumFontGLTest::layout() {
 }
 
 void MagnumFontGLTest::createGlyphCache() {
-    std::unique_ptr<AbstractFont> font = _fontManager.instantiate("MagnumFont");
+    Containers::Pointer<AbstractFont> font = _fontManager.instantiate("MagnumFont");
 
     CORRADE_VERIFY(font->openFile(Utility::Directory::join(MAGNUMFONT_TEST_DIR, "font.conf"), 0.0f));
 
     /* Just testing that nothing crashes, asserts or errors */
-    std::unique_ptr<GlyphCache> cache = font->createGlyphCache();
+    Containers::Pointer<GlyphCache> cache = font->createGlyphCache();
 
     MAGNUM_VERIFY_NO_GL_ERROR();
     CORRADE_VERIFY(cache);

src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterGLTest.cpp

@@ -86,7 +86,7 @@ void MagnumFontConverterGLTest::exportFont() {
                 return {16.0f, 25.0f, -10.0f, 39.7333f};
             }
             Features doFeatures() const { return {}; }
-            std::unique_ptr<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string&) { return nullptr; }
+            Containers::Pointer<AbstractLayouter> doLayout(const GlyphCache&, Float, const std::string&) { return nullptr; }
 
             UnsignedInt doGlyphId(const char32_t character) {
                 switch(character) {
@@ -118,7 +118,7 @@ void MagnumFontConverterGLTest::exportFont() {
     cache.insert(font.glyphId(U'e'), {25, 12}, {{16, 4}, {64, 32}});
 
     /* Convert the file */
-    std::unique_ptr<AbstractFontConverter> converter = _fontConverterManager.instantiate("MagnumFontConverter");
+    Containers::Pointer<AbstractFontConverter> converter = _fontConverterManager.instantiate("MagnumFontConverter");
     converter->exportFontToFile(font, cache, Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font"), "Wave");
 
     /* Verify font parameters */
@@ -131,7 +131,7 @@ void MagnumFontConverterGLTest::exportFont() {
         CORRADE_SKIP("TgaImporter plugin not enabled, not testing glyph cache contents");
 
     /* Verify font image, no need to test image contents, as the image is garbage anyway */
-    std::unique_ptr<Trade::AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    Containers::Pointer<Trade::AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(MAGNUMFONTCONVERTER_TEST_WRITE_DIR, "font.tga")));
     Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
     CORRADE_VERIFY(image);

src/MagnumPlugins/ObjImporter/ObjImporter.cpp

@@ -45,7 +45,7 @@ struct ObjImporter::File {
     std::unordered_map<std::string, UnsignedInt> meshesForName;
     std::vector<std::string> meshNames;
     std::vector<std::tuple<std::streampos, std::streampos, UnsignedInt, UnsignedInt, UnsignedInt>> meshes;
-    std::unique_ptr<std::istream> in;
+    Containers::Pointer<std::istream> in;
 };
 
 namespace {
@@ -102,7 +102,7 @@ void ObjImporter::doClose() { _file.reset(); }
 bool ObjImporter::doIsOpened() const { return !!_file; }
 
 void ObjImporter::doOpenFile(const std::string& filename) {
-    std::unique_ptr<std::istream> in{new std::ifstream{filename, std::ios::binary}};
+    Containers::Pointer<std::istream> in{new std::ifstream{filename, std::ios::binary}};
     if(!in->good()) {
         Error() << "Trade::ObjImporter::openFile(): cannot open file" << filename;
         return;

src/MagnumPlugins/ObjImporter/ObjImporter.h

@@ -100,7 +100,7 @@ class MAGNUM_OBJIMPORTER_EXPORT ObjImporter: public AbstractImporter {
 
         MAGNUM_OBJIMPORTER_LOCAL void parseMeshNames();
 
-        std::unique_ptr<File> _file;
+        Containers::Pointer<File> _file;
 };
 
 }}

src/MagnumPlugins/ObjImporter/Test/ObjImporterTest.cpp

@@ -151,7 +151,7 @@ ObjImporterTest::ObjImporterTest() {
 }
 
 void ObjImporterTest::pointMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "pointMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -170,7 +170,7 @@ void ObjImporterTest::pointMesh() {
 }
 
 void ObjImporterTest::lineMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "lineMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -189,7 +189,7 @@ void ObjImporterTest::lineMesh() {
 }
 
 void ObjImporterTest::triangleMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -209,7 +209,7 @@ void ObjImporterTest::triangleMesh() {
 }
 
 void ObjImporterTest::mixedPrimitives() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "mixedPrimitives.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -220,7 +220,7 @@ void ObjImporterTest::mixedPrimitives() {
 }
 
 void ObjImporterTest::positionsOnly() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "triangleMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -232,7 +232,7 @@ void ObjImporterTest::positionsOnly() {
 }
 
 void ObjImporterTest::textureCoordinates() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinates.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -260,7 +260,7 @@ void ObjImporterTest::textureCoordinates() {
 }
 
 void ObjImporterTest::normals() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "normals.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -288,7 +288,7 @@ void ObjImporterTest::normals() {
 }
 
 void ObjImporterTest::textureCoordinatesNormals() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "textureCoordinatesNormals.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 
@@ -325,13 +325,13 @@ void ObjImporterTest::textureCoordinatesNormals() {
 }
 
 void ObjImporterTest::emptyFile() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
 }
 
 void ObjImporterTest::unnamedMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "emptyFile.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
     CORRADE_COMPARE(importer->mesh3DName(0), "");
@@ -339,7 +339,7 @@ void ObjImporterTest::unnamedMesh() {
 }
 
 void ObjImporterTest::namedMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "namedMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 1);
     CORRADE_COMPARE(importer->mesh3DName(0), "MyMesh");
@@ -347,7 +347,7 @@ void ObjImporterTest::namedMesh() {
 }
 
 void ObjImporterTest::moreMeshes() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "moreMeshes.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 3);
 
@@ -396,7 +396,7 @@ void ObjImporterTest::moreMeshes() {
 }
 
 void ObjImporterTest::unnamedFirstMesh() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "unnamedFirstMesh.obj")));
     CORRADE_COMPARE(importer->mesh3DCount(), 2);
 
@@ -408,7 +408,7 @@ void ObjImporterTest::unnamedFirstMesh() {
 }
 
 void ObjImporterTest::wrongFloat() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
     const Int id = importer->mesh3DForName("WrongFloat");
     CORRADE_VERIFY(id > -1);
@@ -420,7 +420,7 @@ void ObjImporterTest::wrongFloat() {
 }
 
 void ObjImporterTest::wrongInteger() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
     const Int id = importer->mesh3DForName("WrongInteger");
     CORRADE_VERIFY(id > -1);
@@ -432,7 +432,7 @@ void ObjImporterTest::wrongInteger() {
 }
 
 void ObjImporterTest::unmergedIndexOutOfRange() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
     const Int id = importer->mesh3DForName("PositionIndexOutOfRange");
     CORRADE_VERIFY(id > -1);
@@ -444,7 +444,7 @@ void ObjImporterTest::unmergedIndexOutOfRange() {
 }
 
 void ObjImporterTest::mergedIndexOutOfRange() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
     const Int id = importer->mesh3DForName("TextureIndexOutOfRange");
     CORRADE_VERIFY(id > -1);
@@ -456,7 +456,7 @@ void ObjImporterTest::mergedIndexOutOfRange() {
 }
 
 void ObjImporterTest::zeroIndex() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumbers.obj")));
     const Int id = importer->mesh3DForName("ZeroIndex");
     CORRADE_VERIFY(id > -1);
@@ -468,7 +468,7 @@ void ObjImporterTest::zeroIndex() {
 }
 
 void ObjImporterTest::explicitOptionalPositionCoordinate() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
     const Int id = importer->mesh3DForName("SupportedPositionW");
     CORRADE_VERIFY(id > -1);
@@ -482,7 +482,7 @@ void ObjImporterTest::explicitOptionalPositionCoordinate() {
 }
 
 void ObjImporterTest::explicitOptionalTextureCoordinate() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
     const Int id = importer->mesh3DForName("SupportedTextureW");
     CORRADE_VERIFY(id > -1);
@@ -496,7 +496,7 @@ void ObjImporterTest::explicitOptionalTextureCoordinate() {
 }
 
 void ObjImporterTest::unsupportedOptionalPositionCoordinate() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
     const Int id = importer->mesh3DForName("UnsupportedPositionW");
     CORRADE_VERIFY(id > -1);
@@ -508,7 +508,7 @@ void ObjImporterTest::unsupportedOptionalPositionCoordinate() {
 }
 
 void ObjImporterTest::unsupportedOptionalTextureCoordinate() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "optionalCoordinates.obj")));
     const Int id = importer->mesh3DForName("UnsupportedTextureW");
     CORRADE_VERIFY(id > -1);
@@ -520,7 +520,7 @@ void ObjImporterTest::unsupportedOptionalTextureCoordinate() {
 }
 
 void ObjImporterTest::shortFloatData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("ShortFloat");
     CORRADE_VERIFY(id > -1);
@@ -532,7 +532,7 @@ void ObjImporterTest::shortFloatData() {
 }
 
 void ObjImporterTest::longFloatData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("LongFloat");
     CORRADE_VERIFY(id > -1);
@@ -544,7 +544,7 @@ void ObjImporterTest::longFloatData() {
 }
 
 void ObjImporterTest::longOptionalFloatData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("LongOptionalFloat");
     CORRADE_VERIFY(id > -1);
@@ -556,7 +556,7 @@ void ObjImporterTest::longOptionalFloatData() {
 }
 
 void ObjImporterTest::longIndexData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("InvalidIndices");
     CORRADE_VERIFY(id > -1);
@@ -568,7 +568,7 @@ void ObjImporterTest::longIndexData() {
 }
 
 void ObjImporterTest::wrongPointIndexData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("WrongPointIndices");
     CORRADE_VERIFY(id > -1);
@@ -580,7 +580,7 @@ void ObjImporterTest::wrongPointIndexData() {
 }
 
 void ObjImporterTest::wrongLineIndexData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("WrongLineIndices");
     CORRADE_VERIFY(id > -1);
@@ -592,7 +592,7 @@ void ObjImporterTest::wrongLineIndexData() {
 }
 
 void ObjImporterTest::wrongTriangleIndexData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("WrongTriangleIndices");
     CORRADE_VERIFY(id > -1);
@@ -604,7 +604,7 @@ void ObjImporterTest::wrongTriangleIndexData() {
 }
 
 void ObjImporterTest::polygonIndexData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongNumberCount.obj")));
     const Int id = importer->mesh3DForName("PolygonIndices");
     CORRADE_VERIFY(id > -1);
@@ -616,7 +616,7 @@ void ObjImporterTest::polygonIndexData() {
 }
 
 void ObjImporterTest::missingPositionData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingPositionData");
     CORRADE_VERIFY(id > -1);
@@ -628,7 +628,7 @@ void ObjImporterTest::missingPositionData() {
 }
 
 void ObjImporterTest::missingPositionIndices() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingPositionIndices");
     CORRADE_VERIFY(id > -1);
@@ -640,7 +640,7 @@ void ObjImporterTest::missingPositionIndices() {
 }
 
 void ObjImporterTest::missingNormalData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingNormalData");
     CORRADE_VERIFY(id > -1);
@@ -652,7 +652,7 @@ void ObjImporterTest::missingNormalData() {
 }
 
 void ObjImporterTest::missingNormalIndices() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingNormalIndices");
     CORRADE_VERIFY(id > -1);
@@ -664,7 +664,7 @@ void ObjImporterTest::missingNormalIndices() {
 }
 
 void ObjImporterTest::missingTextureCoordinateData() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingTextureData");
     CORRADE_VERIFY(id > -1);
@@ -676,7 +676,7 @@ void ObjImporterTest::missingTextureCoordinateData() {
 }
 
 void ObjImporterTest::missingTextureCoordinateIndices() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "missingData.obj")));
     const Int id = importer->mesh3DForName("MissingTextureIndices");
     CORRADE_VERIFY(id > -1);
@@ -688,7 +688,7 @@ void ObjImporterTest::missingTextureCoordinateIndices() {
 }
 
 void ObjImporterTest::wrongNormalIndexCount() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
     const Int id = importer->mesh3DForName("ShortNormalIndices");
     CORRADE_VERIFY(id > -1);
@@ -700,7 +700,7 @@ void ObjImporterTest::wrongNormalIndexCount() {
 }
 
 void ObjImporterTest::wrongTextureCoordinateIndexCount() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "wrongIndexCount.obj")));
     const Int id = importer->mesh3DForName("ShortTextureIndices");
     CORRADE_VERIFY(id > -1);
@@ -712,7 +712,7 @@ void ObjImporterTest::wrongTextureCoordinateIndexCount() {
 }
 
 void ObjImporterTest::unsupportedKeyword() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
     const Int id = importer->mesh3DForName("UnsupportedKeyword");
     CORRADE_VERIFY(id > -1);
@@ -729,7 +729,7 @@ void ObjImporterTest::unsupportedKeyword() {
 }
 
 void ObjImporterTest::unknownKeyword() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("ObjImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("ObjImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(OBJIMPORTER_TEST_DIR, "keywords.obj")));
     const Int id = importer->mesh3DForName("UnknownKeyword");
     CORRADE_VERIFY(id > -1);

src/MagnumPlugins/TgaImageConverter/Test/TgaImageConverterTest.cpp

@@ -102,21 +102,21 @@ void TgaImageConverterTest::wrongFormat() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    Containers::Pointer<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
     const auto data = converter->exportToData(image);
     CORRADE_VERIFY(!data);
     CORRADE_COMPARE(out.str(), "Trade::TgaImageConverter::exportToData(): unsupported pixel format PixelFormat::RG8Unorm\n");
 }
 
 void TgaImageConverterTest::rgb() {
-    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    Containers::Pointer<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
     const auto data = converter->exportToData(OriginalRGB);
     CORRADE_VERIFY(data);
 
     if(!(_importerManager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
         CORRADE_SKIP("TgaImporter plugin not enabled, can't test the result");
 
-    std::unique_ptr<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
     CORRADE_VERIFY(importer->openData(data));
     Containers::Optional<Trade::ImageData2D> converted = importer->image2D(0);
     CORRADE_VERIFY(converted);
@@ -129,14 +129,14 @@ void TgaImageConverterTest::rgb() {
 }
 
 void TgaImageConverterTest::rgba() {
-    std::unique_ptr<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
+    Containers::Pointer<AbstractImageConverter> converter = _converterManager.instantiate("TgaImageConverter");
     const auto data = converter->exportToData(OriginalRGBA);
     CORRADE_VERIFY(data);
 
     if(!(_importerManager.loadState("TgaImporter") & PluginManager::LoadState::Loaded))
         CORRADE_SKIP("TgaImporter plugin not enabled, can't test the result");
 
-    std::unique_ptr<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _importerManager.instantiate("TgaImporter");
     CORRADE_VERIFY(importer->openData(data));
     Containers::Optional<Trade::ImageData2D> converted = importer->image2D(0);
     CORRADE_VERIFY(converted);

src/MagnumPlugins/TgaImporter/Test/TgaImporterTest.cpp

@@ -80,7 +80,7 @@ TgaImporterTest::TgaImporterTest() {
 }
 
 void TgaImporterTest::openShort() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     CORRADE_VERIFY(importer->openData(data));
 
@@ -91,7 +91,7 @@ void TgaImporterTest::openShort() {
 }
 
 void TgaImporterTest::paletted() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     CORRADE_VERIFY(importer->openData(data));
 
@@ -102,7 +102,7 @@ void TgaImporterTest::paletted() {
 }
 
 void TgaImporterTest::compressed() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     CORRADE_VERIFY(importer->openData(data));
 
@@ -113,7 +113,7 @@ void TgaImporterTest::compressed() {
 }
 
 void TgaImporterTest::colorBits16() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0 };
     CORRADE_VERIFY(importer->openData(data));
 
@@ -124,7 +124,7 @@ void TgaImporterTest::colorBits16() {
 }
 
 void TgaImporterTest::colorBits24() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 24, 0,
         1, 2, 3, 2, 3, 4,
@@ -148,7 +148,7 @@ void TgaImporterTest::colorBits24() {
 }
 
 void TgaImporterTest::colorBits32() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 32, 0,
         1, 2, 3, 1, 2, 3, 4, 1,
@@ -172,7 +172,7 @@ void TgaImporterTest::colorBits32() {
 }
 
 void TgaImporterTest::grayscaleBits8() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = {
         0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 8, 0,
         1, 2,
@@ -191,7 +191,7 @@ void TgaImporterTest::grayscaleBits8() {
 }
 
 void TgaImporterTest::grayscaleBits16() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     const char data[] = { 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0 };
     CORRADE_VERIFY(importer->openData(data));
 
@@ -202,7 +202,7 @@ void TgaImporterTest::grayscaleBits16() {
 }
 
 void TgaImporterTest::useTwice() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("TgaImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("TgaImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(TGAIMPORTER_TEST_DIR, "file.tga")));
 
     /* Verify that the file is rewinded for second use */

src/MagnumPlugins/WavAudioImporter/Test/WavImporterTest.cpp

@@ -121,7 +121,7 @@ void WavImporterTest::wrongSize() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openData(Containers::Array<char>(43)));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file is too short: 43 bytes\n");
 }
@@ -130,7 +130,7 @@ void WavImporterTest::wrongSignature() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "wrongSignature.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file signature is invalid\n");
 }
@@ -139,7 +139,7 @@ void WavImporterTest::unsupportedFormat() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedFormat.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
@@ -148,7 +148,7 @@ void WavImporterTest::unsupportedChannelCount() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedChannelCount.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 6 with 8 bits per sample\n");
 }
@@ -157,7 +157,7 @@ void WavImporterTest::invalidPadding() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidPadding.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file has improper size, expected 66 but got 73\n");
 }
@@ -166,7 +166,7 @@ void WavImporterTest::invalidLength() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidLength.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file has improper size, expected 160844 but got 80444\n");
 }
@@ -175,13 +175,13 @@ void WavImporterTest::invalidDataChunk() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidDataChunk.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): the file contains no data chunk\n");
 }
 
 void WavImporterTest::invalidFactChunk() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "invalidFactChunk.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Mono16);
@@ -198,13 +198,13 @@ void WavImporterTest::mono4() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono4.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
 
 void WavImporterTest::mono8() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Mono8);
@@ -217,7 +217,7 @@ void WavImporterTest::mono8() {
 }
 
 void WavImporterTest::mono8junk() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8junk.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Mono8);
@@ -229,7 +229,7 @@ void WavImporterTest::mono8junk() {
 }
 
 void WavImporterTest::mono8ALaw() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8ALaw.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::MonoALaw);
@@ -243,7 +243,7 @@ void WavImporterTest::mono8ALaw() {
 }
 
 void WavImporterTest::mono8MuLaw() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono8MuLaw.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::MonoMuLaw);
@@ -257,7 +257,7 @@ void WavImporterTest::mono8MuLaw() {
 }
 
 void WavImporterTest::mono16() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono16.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Mono16);
@@ -273,13 +273,13 @@ void WavImporterTest::stereo4() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo4.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::AdPcm\n");
 }
 
 void WavImporterTest::stereo8() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Stereo8);
@@ -292,7 +292,7 @@ void WavImporterTest::stereo8() {
 }
 
 void WavImporterTest::stereo8ALaw() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8ALaw.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::StereoALaw);
@@ -306,7 +306,7 @@ void WavImporterTest::stereo8ALaw() {
 }
 
 void WavImporterTest::stereo8MuLaw() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo8MuLaw.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::StereoMuLaw);
@@ -323,13 +323,13 @@ void WavImporterTest::stereo12() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo12.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 12 bits per sample\n");
 }
 
 void WavImporterTest::stereo16() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo16.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::Stereo16);
@@ -344,7 +344,7 @@ void WavImporterTest::stereo24() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo24.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 24 bits per sample\n");
 }
@@ -353,13 +353,13 @@ void WavImporterTest::stereo32() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): PCM with unsupported channel count 2 with 32 bits per sample\n");
 }
 
 void WavImporterTest::mono32f() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "mono32f.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::MonoFloat);
@@ -373,7 +373,7 @@ void WavImporterTest::mono32f() {
 }
 
 void WavImporterTest::stereo32f() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo32f.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::StereoFloat);
@@ -387,7 +387,7 @@ void WavImporterTest::stereo32f() {
 }
 
 void WavImporterTest::stereo64f() {
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "stereo64f.wav")));
 
     CORRADE_COMPARE(importer->format(), BufferFormat::StereoDouble);
@@ -407,7 +407,7 @@ void WavImporterTest::surround51Channel16() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround51Channel16.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::Extensible\n");
 }
@@ -416,7 +416,7 @@ void WavImporterTest::surround71Channel24() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    std::unique_ptr<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
+    Containers::Pointer<AbstractImporter> importer = _manager.instantiate("WavAudioImporter");
     CORRADE_VERIFY(!importer->openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround71Channel24.wav")));
     CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::Extensible\n");
 }