Adapt to Corrade changes.

doc/generated/colormaps.cpp

@@ -56,7 +56,7 @@ int main() {
         constexpr Vector2i OutputSize{256, 12};
         CORRADE_INTERNAL_ASSERT(image.first.size() == std::size_t(OutputSize.x()));
 
-        Containers::Array<Vector3ub> data{Containers::NoInit, std::size_t(OutputSize.product())};
+        Containers::Array<Vector3ub> data{NoInit, std::size_t(OutputSize.product())};
         Containers::StridedArrayView2D<const Vector3ub> src{image.first,
             {std::size_t(OutputSize.y()), std::size_t(OutputSize.x())}, {0, 3}};
         Containers::StridedArrayView2D<Vector3ub> dst{data,

src/Magnum/Animation/Player.hpp

@@ -106,7 +106,7 @@ template<class T, class K> Player<T, K>& Player<T, K>::addInternal(const TrackVi
         _duration = track.duration();
     else
         _duration = Math::join(track.duration(), _duration);
-    arrayAppend(_tracks, Containers::InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u);
+    arrayAppend(_tracks, InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u);
     return *this;
 }
 
@@ -252,7 +252,7 @@ template<class T, class K> Containers::Optional<std::pair<UnsignedInt, K>> playe
         }
     }
 
-    return {Containers::InPlaceInit, playIteration, key};
+    return {InPlaceInit, playIteration, key};
 }
 
 }

src/Magnum/Animation/Test/Benchmark.cpp

@@ -83,8 +83,8 @@ Benchmark::Benchmark() {
                    &Benchmark::playerAdvanceRawCallbackDirectInterpolator}, 10);
 
     _keys = Containers::Array<Float>{DataSize};
-    _values = Containers::Array<Int>{Containers::DirectInit, DataSize, 1};
-    _interleaved = Containers::Array<std::pair<Float, Int>>{Containers::DirectInit, DataSize, 0.0f, 1};
+    _values = Containers::Array<Int>{DirectInit, DataSize, 1};
+    _interleaved = Containers::Array<std::pair<Float, Int>>{DirectInit, DataSize, 0.0f, 1};
     for(std::size_t i = 0; i != DataSize; ++i)
         _keys[i] = _interleaved[i].first = Float(i)*3.1254f;
 

src/Magnum/Animation/Test/TrackTest.cpp

@@ -132,7 +132,7 @@ void TrackTest::constructEmpty() {
 
 void TrackTest::constructArrayInterpolator() {
     Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}},
              {5.0f, {0.3f, 0.6f, 1.0f}}}},
         Math::select, Extrapolation::Extrapolated, Extrapolation::Constant};
@@ -162,7 +162,7 @@ void TrackTest::constructArrayInterpolator() {
 
 void TrackTest::constructArrayInterpolatorDefaults() {
     const Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}}}},
         Math::lerp, Extrapolation::DefaultConstructed};
 
@@ -183,7 +183,7 @@ void TrackTest::constructArrayInterpolatorDefaults() {
 
 void TrackTest::constructArrayInterpolation() {
     const Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}},
              {5.0f, {0.3f, 0.6f, 1.0f}}}},
         Interpolation::Linear, Extrapolation::Extrapolated, Extrapolation::Constant};
@@ -205,7 +205,7 @@ void TrackTest::constructArrayInterpolation() {
 
 void TrackTest::constructArrayInterpolationDefaults() {
     const Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}}}},
         Interpolation::Constant, Extrapolation::DefaultConstructed};
 
@@ -228,7 +228,7 @@ Vector3 customLerp(const Vector3&, const Vector3&, Float) { return {}; }
 
 void TrackTest::constructArrayInterpolationInterpolator() {
     const Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}},
              {5.0f, {0.3f, 0.6f, 1.0f}}}},
         Interpolation::Linear, customLerp, Extrapolation::Extrapolated, Extrapolation::Constant};
@@ -250,7 +250,7 @@ void TrackTest::constructArrayInterpolationInterpolator() {
 
 void TrackTest::constructArrayInterpolationInterpolationDefaults() {
     const Track<Float, Vector3> a{
-        Containers::Array<std::pair<Float, Vector3>>{Containers::InPlaceInit,
+        Containers::Array<std::pair<Float, Vector3>>{InPlaceInit,
             {{1.0f, {3.0f, 1.0f, 0.1f}}}},
         Interpolation::Constant, customLerp, Extrapolation::DefaultConstructed};
 

src/Magnum/Animation/Track.h

@@ -164,7 +164,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolator interpolator, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolator}, _interpolation{Interpolation::Custom}, _before{before}, _after{after} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolator interpolator, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolator, before, after} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolator interpolator, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolator, before, after} {}
 
         /** @overload
          * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolator, Extrapolation, Extrapolation)
@@ -173,7 +173,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track<K, V, R>{std::move(data), interpolator, extrapolation, extrapolation} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolator, extrapolation, extrapolation} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolator, extrapolation, extrapolation} {}
 
         /**
          * @brief Construct with both generic and custom interpolator
@@ -192,7 +192,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolator}, _interpolation{interpolation}, _before{before}, _after{after} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolation, interpolator, before, after} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Interpolator interpolator, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolation, interpolator, before, after} {}
 
         /** @overload
          * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolation, Interpolator, Extrapolation, Extrapolation)
@@ -201,7 +201,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track<K, V, R>{std::move(data), interpolation, interpolator, extrapolation, extrapolation} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolation, interpolator, extrapolation} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Interpolator interpolator, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolation, interpolator, extrapolation} {}
 
         /**
          * @brief Construct with generic interpolation behavior
@@ -219,7 +219,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolation interpolation, Extrapolation before, Extrapolation after) noexcept: _data{std::move(data)}, _interpolator{interpolatorFor<V, R>(interpolation)}, _interpolation{interpolation}, _before{before}, _after{after} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolation, before, after} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Extrapolation before, Extrapolation after): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolation, before, after} {}
 
         /** @overload
          * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolation, Extrapolation, Extrapolation)
@@ -228,7 +228,7 @@ template<class K, class V, class R
         explicit Track(Containers::Array<std::pair<K, V>>&& data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant) noexcept: Track<K, V, R>{std::move(data), interpolation, extrapolation, extrapolation} {}
 
         /** @overload */
-        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{Containers::InPlaceInit, data}, interpolation, extrapolation, extrapolation} {}
+        explicit Track(std::initializer_list<std::pair<K, V>> data, Interpolation interpolation, Extrapolation extrapolation = Extrapolation::Constant): Track<K, V, R>{Containers::Array<std::pair<K, V>>{InPlaceInit, data}, interpolation, extrapolation, extrapolation} {}
 
         /** @brief Copying is not allowed */
         Track(const Track<K, V, R>&) = delete;

src/Magnum/Audio/Test/AbstractImporterTest.cpp

@@ -340,7 +340,7 @@ void AbstractImporterTest::data() {
         }
     } importer;
 
-    CORRADE_COMPARE_AS(importer.data(), (Containers::Array<char>{Containers::InPlaceInit, {'H'}}), TestSuite::Compare::Container);
+    CORRADE_COMPARE_AS(importer.data(), (Containers::Array<char>{InPlaceInit, {'H'}}), TestSuite::Compare::Container);
 }
 
 void AbstractImporterTest::dataNoFile() {

src/Magnum/DebugTools/CompareImage.cpp

@@ -95,7 +95,7 @@ template<std::size_t size, class T> Float calculateImageDelta(const Containers::
 
 std::tuple<Containers::Array<Float>, Float, Float> calculateImageDelta(const PixelFormat actualFormat, const Containers::StridedArrayView3D<const char>& actualPixels, const ImageView2D& expected) {
     /* Calculate a delta image */
-    Containers::Array<Float> deltaData{Containers::NoInit,
+    Containers::Array<Float> deltaData{NoInit,
         std::size_t(expected.size().product())};
     Containers::StridedArrayView2D<Float> delta{deltaData,
         {std::size_t(expected.size().y()), std::size_t(expected.size().x())}};
@@ -446,7 +446,7 @@ class ImageComparatorBase::State {
         Containers::Array<Float> delta;
 };
 
-ImageComparatorBase::ImageComparatorBase(PluginManager::Manager<Trade::AbstractImporter>* importerManager, PluginManager::Manager<Trade::AbstractImageConverter>* converterManager, Float maxThreshold, Float meanThreshold): _state{Containers::InPlaceInit, importerManager, converterManager, maxThreshold, meanThreshold} {
+ImageComparatorBase::ImageComparatorBase(PluginManager::Manager<Trade::AbstractImporter>* importerManager, PluginManager::Manager<Trade::AbstractImageConverter>* converterManager, Float maxThreshold, Float meanThreshold): _state{InPlaceInit, importerManager, converterManager, maxThreshold, meanThreshold} {
     CORRADE_ASSERT(!Math::isNan(maxThreshold) && !Math::isInf(maxThreshold) &&
                    !Math::isNan(meanThreshold) && !Math::isInf(meanThreshold),
         "DebugTools::CompareImage: thresholds can't be NaN or infinity", );

src/Magnum/DebugTools/FrameProfiler.cpp

@@ -181,7 +181,7 @@ void FrameProfiler::endFrame() {
 
     /* If we don't have all frames yet, enlarge the array */
     if(++_measuredFrameCount <= _maxFrameCount)
-        arrayAppend(_data, Containers::NoInit, _measurements.size());
+        arrayAppend(_data, NoInit, _measurements.size());
 
     /* Wrap up measurements for this frame  */
     for(std::size_t i = 0; i != _measurements.size(); ++i) {
@@ -448,7 +448,7 @@ struct GLFrameProfiler::State {
     #endif
 };
 
-GLFrameProfiler::GLFrameProfiler(): _state{Containers::InPlaceInit} {}
+GLFrameProfiler::GLFrameProfiler(): _state{InPlaceInit} {}
 
 GLFrameProfiler::GLFrameProfiler(const Values values, const UnsignedInt maxFrameCount): GLFrameProfiler{}
 {
@@ -468,7 +468,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount
         /* Fucking hell, STL. When I first saw std::chrono back in 2010 I
            should have flipped the table and learn carpentry instead. BUT NO,
            I'm still suffering this abomination a decade later! */
-        arrayAppend(measurements, Containers::InPlaceInit,
+        arrayAppend(measurements, InPlaceInit,
             "Frame time", Units::Nanoseconds, UnsignedInt(Containers::arraySize(_state->frameTimeStartFrame)),
             [](void* state, UnsignedInt current) {
                 static_cast<State*>(state)->frameTimeStartFrame[current] = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
@@ -482,7 +482,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount
         _state->frameTimeIndex = index++;
     }
     if(values & Value::CpuDuration) {
-        arrayAppend(measurements, Containers::InPlaceInit,
+        arrayAppend(measurements, InPlaceInit,
             "CPU duration", Units::Nanoseconds,
             [](void* state) {
                 static_cast<State*>(state)->cpuDurationStartFrame = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
@@ -496,7 +496,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount
     if(values & Value::GpuDuration) {
         for(GL::TimeQuery& q: _state->timeQueries)
             q = GL::TimeQuery{GL::TimeQuery::Target::TimeElapsed};
-        arrayAppend(measurements, Containers::InPlaceInit,
+        arrayAppend(measurements, InPlaceInit,
             "GPU duration", Units::Nanoseconds,
             UnsignedInt(Containers::arraySize(_state->timeQueries)),
             [](void* state, UnsignedInt current) {
@@ -516,7 +516,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount
             q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VerticesSubmitted};
         for(GL::PipelineStatisticsQuery& q: _state->vertexShaderInvocationsQueries)
             q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VertexShaderInvocations};
-        arrayAppend(measurements, Containers::InPlaceInit,
+        arrayAppend(measurements, InPlaceInit,
             "Vertex fetch ratio", Units::RatioThousandths,
             UnsignedInt(Containers::arraySize(_state->verticesSubmittedQueries)),
             [](void* state, UnsignedInt current) {
@@ -541,7 +541,7 @@ void GLFrameProfiler::setup(const Values values, const UnsignedInt maxFrameCount
             q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingInputPrimitives};
         for(GL::PipelineStatisticsQuery& q: _state->clippingOutputPrimitivesQueries)
             q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingOutputPrimitives};
-        arrayAppend(measurements, Containers::InPlaceInit,
+        arrayAppend(measurements, InPlaceInit,
             "Primitives clipped", Units::PercentageThousandths,
             UnsignedInt(Containers::arraySize(_state->clippingInputPrimitivesQueries)),
             [](void* state, UnsignedInt current) {

src/Magnum/DebugTools/Test/CompareImageTest.cpp

@@ -317,10 +317,10 @@ void CompareImageTest::calculateDeltaStorage() {
     Float max, mean;
     std::tie(delta, max, mean) = Implementation::calculateImageDelta(ActualRgb.format(), ActualRgb.pixels(), ExpectedRgb);
 
-    CORRADE_COMPARE_AS(delta, (Containers::Array<Float>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(delta, Containers::arrayView<Float>({
         1.0f/3.0f, (55.0f + 1.0f)/3.0f,
         48.0f/3.0f, 117.0f/3.0f
-    }}), TestSuite::Compare::Container);
+    }), TestSuite::Compare::Container);
     CORRADE_COMPARE(max, 117.0f/3.0f);
     CORRADE_COMPARE(mean, 18.5f);
 }
@@ -381,9 +381,9 @@ void CompareImageTest::calculateDeltaSpecials3() {
     Containers::Array<Float> delta;
     Float max, mean;
     std::tie(delta, max, mean) = Implementation::calculateImageDelta(actualSpecials3.format(), actualSpecials3.pixels(), expectedSpecials3);
-    CORRADE_COMPARE_AS(delta, (Containers::Array<Float>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(delta, Containers::arrayView<Float>({
         Constants::nan(), Constants::nan(), 1.15f
-    }}), TestSuite::Compare::Container);
+    }), TestSuite::Compare::Container);
     /* Max and mean should be calculated *without* the specials because
        otherwise every other potential difference will be zero compared to
        infinity */

src/Magnum/DebugTools/Test/ForceRendererGLTest.cpp

@@ -117,7 +117,7 @@ void ForceRendererGLTest::render2D() {
        the arrowhead to be on a different place (but the rest is okay and the
        3D case matches exactly), however to avoid false negatives elsewhere I'm
        making it conditional. */
-    Containers::Optional<CompareImageToFile> comparator{Containers::InPlaceInit, _manager};
+    Containers::Optional<CompareImageToFile> comparator{InPlaceInit, _manager};
     #ifdef CORRADE_TARGET_ANDROID
     if(GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali)
         comparator.emplace(_manager, 79.0f, 0.22f);

src/Magnum/DebugTools/Test/FrameProfilerTest.cpp

@@ -1114,8 +1114,7 @@ void FrameProfilerTest::gl() {
     setTestCaseDescription(data.name);
 
     /* Test that we use the right state pointers to survive a move */
-    Containers::Pointer<GLFrameProfiler> profiler_{Containers::InPlaceInit,
-        data.values, 4u};
+    Containers::Pointer<GLFrameProfiler> profiler_{InPlaceInit, data.values, 4u};
     GLFrameProfiler profiler = std::move(*profiler_);
     profiler_ = nullptr;
     CORRADE_COMPARE(profiler.values(), data.values);

src/Magnum/DebugTools/Test/ObjectRendererGLTest.cpp

@@ -164,7 +164,7 @@ void ObjectRendererGLTest::render3D() {
        the bottom blue line to be on a different place (but the rest is
        okay and the 2D case matches exactly), however to avoid false negatives
        elsewhere I'm making it conditional. */
-    Containers::Optional<CompareImageToFile> comparator{Containers::InPlaceInit, _manager,  71.6f, 0.018f};
+    Containers::Optional<CompareImageToFile> comparator{InPlaceInit, _manager,  71.6f, 0.018f};
     #ifdef CORRADE_TARGET_ANDROID
     if(GL::Context::current().detectedDriver() & GL::Context::DetectedDriver::ArmMali)
         comparator.emplace(_manager, 127.6f, 0.54f);

src/Magnum/GL/Context.cpp

@@ -796,7 +796,7 @@ bool Context::tryCreate(const Configuration& configuration) {
     /* Driver workarounds get merged. Not using disableDriverWorkaround() here
        since the Configuration already contains the internal string views. */
     for(const Containers::StringView workaround: configuration.disabledWorkarounds())
-        arrayAppend(_driverWorkarounds, Containers::InPlaceInit, workaround, true);
+        arrayAppend(_driverWorkarounds, InPlaceInit, workaround, true);
 
     /* Extensions get merged also. Here we had the chance to force users to
        give us the predefined extension types so no need to search for their
@@ -1208,7 +1208,7 @@ Context::Configuration& Context::Configuration::operator=(const Configuration& o
     _flags = other._flags;
     arrayResize(_disabledWorkarounds, 0);
     /** @todo arrayClear(), ffs */
-    arrayResize(_disabledExtensions, Containers::NoInit, 0);
+    arrayResize(_disabledExtensions, NoInit, 0);
     addDisabledWorkarounds(other._disabledWorkarounds);
     addDisabledExtensions(other._disabledExtensions);
     return *this;

src/Magnum/GL/DefaultFramebuffer.cpp

@@ -69,7 +69,7 @@ DefaultFramebuffer& DefaultFramebuffer::mapForDraw(std::initializer_list<std::pa
     /* Create linear array from associative */
     /** @todo C++14: use VLA to avoid heap allocation */
     static_assert(GL_NONE == 0, "Expecting zero GL_NONE for zero-initialization");
-    Containers::Array<GLenum> _attachments{Containers::ValueInit, max+1};
+    Containers::Array<GLenum> _attachments{ValueInit, max+1};
     for(const auto& attachment: attachments)
         _attachments[attachment.first] = GLenum(attachment.second);
 

src/Magnum/GL/Framebuffer.cpp

@@ -185,7 +185,7 @@ Framebuffer& Framebuffer::mapForDraw(std::initializer_list<std::pair<UnsignedInt
     /* Create linear array from associative */
     /** @todo C++14: use VLA to avoid heap allocation */
     static_assert(GL_NONE == 0, "Expecting zero GL_NONE for zero-initialization");
-    Containers::Array<GLenum> _attachments{Containers::ValueInit, max+1};
+    Containers::Array<GLenum> _attachments{ValueInit, max+1};
     for(const auto& attachment: attachments)
         _attachments[attachment.first] = GLenum(attachment.second);
 

src/Magnum/GL/Implementation/State.cpp

@@ -92,25 +92,25 @@ std::pair<Containers::ArrayTuple, State&> State::allocate(Context& context, std:
     Containers::ArrayView<TransformFeedbackState> transformFeedbackStateView;
     #endif
     Containers::ArrayTuple data{
-        {Containers::NoInit, 1, stateView},
-        {Containers::NoInit, 1, bufferStateView},
-        {Containers::NoInit, 1, contextStateView},
+        {NoInit, 1, stateView},
+        {NoInit, 1, bufferStateView},
+        {NoInit, 1, contextStateView},
         #ifndef MAGNUM_TARGET_WEBGL
-        {Containers::NoInit, 1, debugStateView},
+        {NoInit, 1, debugStateView},
         #endif
-        {Containers::NoInit, 1, framebufferStateView},
-        {Containers::NoInit, 1, meshStateView},
-        {Containers::NoInit, 1, queryStateView},
-        {Containers::NoInit, 1, rendererStateView},
-        {Containers::NoInit, 1, shaderStateView},
-        {Containers::NoInit, 1, shaderProgramStateView},
-        {Containers::NoInit, 1, textureStateView},
-        {Containers::ValueInit, std::size_t(maxTextureUnits), textureBindings},
+        {NoInit, 1, framebufferStateView},
+        {NoInit, 1, meshStateView},
+        {NoInit, 1, queryStateView},
+        {NoInit, 1, rendererStateView},
+        {NoInit, 1, shaderStateView},
+        {NoInit, 1, shaderProgramStateView},
+        {NoInit, 1, textureStateView},
+        {ValueInit, std::size_t(maxTextureUnits), textureBindings},
         #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
-        {Containers::ValueInit, std::size_t(maxImageUnits), imageBindings},
+        {ValueInit, std::size_t(maxImageUnits), imageBindings},
         #endif
         #ifndef MAGNUM_TARGET_GLES2
-        {Containers::NoInit, 1, transformFeedbackStateView}
+        {NoInit, 1, transformFeedbackStateView}
         #endif
     };
 

src/Magnum/GL/Implementation/driverSpecific.cpp

@@ -496,7 +496,7 @@ void Context::disableDriverWorkaround(const Containers::StringView workaround) {
         return;
     }
 
-    arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, true);
+    arrayAppend(_driverWorkarounds, InPlaceInit, found, true);
 }
 
 bool Context::isDriverWorkaroundDisabled(const Containers::StringView workaround) {
@@ -512,7 +512,7 @@ bool Context::isDriverWorkaroundDisabled(const Containers::StringView workaround
        the views in the KnownWorkarounds list. */
     for(const auto& i: _driverWorkarounds)
         if(i.first.data() == found.data()) return i.second;
-    arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, false);
+    arrayAppend(_driverWorkarounds, InPlaceInit, found, false);
     return false;
 }
 
@@ -633,7 +633,7 @@ Context::Configuration& Context::Configuration::addDisabledWorkarounds(Container
             continue;
         }
 
-        arrayAppend(_disabledWorkarounds, Containers::InPlaceInit, found);
+        arrayAppend(_disabledWorkarounds, InPlaceInit, found);
     }
 
     return *this;

src/Magnum/GL/Test/FramebufferGLTest.cpp

@@ -1728,7 +1728,7 @@ void FramebufferGLTest::copyImageTexture1D() {
 
     CORRADE_COMPARE(texture.imageSize(0)[0], 2);
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b}}),
+        Containers::arrayView<char>({0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b}),
         TestSuite::Compare::Container);
 }
 #endif
@@ -1770,9 +1770,9 @@ void FramebufferGLTest::copyImageTexture2D() {
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE(texture.imageSize(0), Vector2i{2});
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
-            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}),
+            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -1798,9 +1798,9 @@ void FramebufferGLTest::copyImageTexture1DArray() {
 
     CORRADE_COMPARE(texture.imageSize(0), Vector2i{2});
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
-            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}),
+            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}),
         TestSuite::Compare::Container);
 }
 
@@ -1824,9 +1824,9 @@ void FramebufferGLTest::copyImageRectangleTexture() {
 
     CORRADE_COMPARE(texture.imageSize(), Vector2i{2});
     CORRADE_COMPARE_AS(texture.image({PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
-            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}),
+            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}),
         TestSuite::Compare::Container);
 }
 #endif
@@ -1875,9 +1875,9 @@ void FramebufferGLTest::copyImageCubeMapTexture() {
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE(texture.imageSize(0), Vector2i{2});
     CORRADE_COMPARE_AS(texture.image(CubeMapCoordinate::PositiveX, 0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
-            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}}),
+            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -1902,8 +1902,8 @@ void FramebufferGLTest::copySubImageTexture1D() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
-            0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00}}),
+        Containers::arrayView<char>({
+            0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
 }
 #endif
@@ -1946,11 +1946,11 @@ void FramebufferGLTest::copySubImageTexture2D() {
 
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -1993,7 +1993,7 @@ void FramebufferGLTest::copySubImageTexture3D() {
 
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -2002,7 +2002,7 @@ void FramebufferGLTest::copySubImageTexture3D() {
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -2030,11 +2030,11 @@ void FramebufferGLTest::copySubImageTexture1DArray() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
 }
 #endif
@@ -2064,7 +2064,7 @@ void FramebufferGLTest::copySubImageTexture2DArray() {
 
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -2073,7 +2073,7 @@ void FramebufferGLTest::copySubImageTexture2DArray() {
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -2101,11 +2101,11 @@ void FramebufferGLTest::copySubImageRectangleTexture() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 
     CORRADE_COMPARE_AS(texture.image({PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
 }
 #endif
@@ -2148,11 +2148,11 @@ void FramebufferGLTest::copySubImageCubeMapTexture() {
 
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(texture.image(CubeMapCoordinate::NegativeY, 0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
     #endif
 }
@@ -2185,7 +2185,7 @@ void FramebufferGLTest::copySubImageCubeMapTextureArray() {
 
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(texture.image(0, {PixelFormat::RGBA, PixelType::UnsignedByte}).release(),
-        (Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::arrayView<char>({
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -2214,7 +2214,7 @@ void FramebufferGLTest::copySubImageCubeMapTextureArray() {
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}),
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
         TestSuite::Compare::Container);
     #endif
 }

src/Magnum/GL/Test/PixelStorageGLTest.cpp

@@ -120,7 +120,7 @@ void PixelStorageGLTest::unpack2D() {
     /* Read into zero-initialized array to avoid comparing random memory in
        padding bytes (confirmed on NVidia 355.11, AMD 15.300.1025.0) */
     Image2D actual{PixelFormat::RGB, PixelType::UnsignedByte, {},
-        Containers::Array<char>{Containers::ValueInit, sizeof(ActualData)}};
+        Containers::Array<char>{ValueInit, sizeof(ActualData)}};
 
     #ifndef MAGNUM_TARGET_GLES
     texture.image(0, actual);
@@ -158,7 +158,7 @@ void PixelStorageGLTest::pack2D() {
         .setAlignment(2)
         .setRowLength(3)
         .setSkip({1, 3, 0}),
-        PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array<char>{Containers::ValueInit, sizeof(Data2D)}};
+        PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array<char>{ValueInit, sizeof(Data2D)}};
 
     #ifndef MAGNUM_TARGET_GLES
     texture.image(0, image);
@@ -218,7 +218,7 @@ void PixelStorageGLTest::unpack3D() {
     /* Read into zero-initialized array to avoid comparing random memory in
        padding bytes (confirmed on AMD 15.300.1025.0) */
     Image3D actual{PixelFormat::RGB, PixelType::UnsignedByte, {},
-        Containers::Array<char>{Containers::ValueInit, sizeof(ActualData)}};
+        Containers::Array<char>{ValueInit, sizeof(ActualData)}};
 
     texture.image(0, actual);
 
@@ -252,7 +252,7 @@ void PixelStorageGLTest::pack3D() {
         .setRowLength(3)
         .setImageHeight(5)
         .setSkip({1, 2, 1}),
-        PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array<char>{Containers::ValueInit, sizeof(Data3D)}};
+        PixelFormat::RGB, PixelType::UnsignedByte, {}, Containers::Array<char>{ValueInit, sizeof(Data3D)}};
     texture.image(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -330,7 +330,7 @@ void PixelStorageGLTest::packCompressed2D() {
         .setCompressedBlockDataSize(16)
         .setRowLength(12)
         .setSkip({4, 4, 0}),
-        CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array<char>{Containers::ValueInit, sizeof(CompressedData2D)}};
+        CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array<char>{ValueInit, sizeof(CompressedData2D)}};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();
@@ -438,7 +438,7 @@ void PixelStorageGLTest::packCompressed3D() {
         .setRowLength(8)
         .setImageHeight(8)
         .setSkip({4, 4, 4}),
-        CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array<char>{Containers::ValueInit, sizeof(CompressedData3D)}};
+        CompressedPixelFormat::RGBAS3tcDxt3, {}, Containers::Array<char>{ValueInit, sizeof(CompressedData3D)}};
     texture.compressedImage(0, image);
 
     MAGNUM_VERIFY_NO_GL_ERROR();

src/Magnum/Implementation/ImageProperties.h

@@ -51,7 +51,7 @@ template<UnsignedInt dimensions, class T, class Image, class Data> Containers::S
     /* Size in the last dimension is byte size of the pixel, the remaining
        dimensions are reverted (first images, then rows, then pixels, last
        pixel bytes) */
-    Containers::StridedDimensions<dimensions + 1, std::size_t> size{Containers::NoInit};
+    Containers::StridedDimensions<dimensions + 1, std::size_t> size{NoInit};
     size[dimensions] = image.pixelSize();
     for(UnsignedInt i = dimensions; i != 0; --i)
         size[i - 1] = image.size()[dimensions - i];
@@ -61,7 +61,7 @@ template<UnsignedInt dimensions, class T, class Image, class Data> Containers::S
        (first image size, then row size, then pixel size, last 1). The
        data properties include pixel size in row size, so we have to take it
        out from the cumulative product. */
-    Containers::StridedDimensions<dimensions + 1, std::ptrdiff_t> stride{Containers::NoInit};
+    Containers::StridedDimensions<dimensions + 1, std::ptrdiff_t> stride{NoInit};
     stride[dimensions] = 1;
     stride[dimensions - 1] = 1;
     for(UnsignedInt i = dimensions - 1; i != 0; --i)

src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp

@@ -143,7 +143,7 @@ void KahanSumTest::iterative() {
 }
 
 void KahanSumTest::accumulate100kFloats() {
-    Containers::Array<Float> data(Containers::DirectInit, 100000, 1.0f);
+    Containers::Array<Float> data(DirectInit, 100000, 1.0f);
 
     volatile Float a; /* to avoid optimizing the loop out */
     CORRADE_BENCHMARK(10) {
@@ -154,7 +154,7 @@ void KahanSumTest::accumulate100kFloats() {
 }
 
 void KahanSumTest::accumulate100kDoubles() {
-    Containers::Array<Double> data(Containers::DirectInit, 100000, 1.0);
+    Containers::Array<Double> data(DirectInit, 100000, 1.0);
 
     volatile Double a; /* to avoid optimizing the loop out */
     CORRADE_BENCHMARK(10) {
@@ -165,7 +165,7 @@ void KahanSumTest::accumulate100kDoubles() {
 }
 
 void KahanSumTest::kahan100kFloats() {
-    Containers::Array<Float> data(Containers::DirectInit, 100000, 1.0f);
+    Containers::Array<Float> data(DirectInit, 100000, 1.0f);
 
     volatile Float a; /* to avoid optimizing the loop out */
     CORRADE_BENCHMARK(10) {

src/Magnum/Math/Tags.h

@@ -29,8 +29,6 @@
  * @brief Tag type @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit
  */
 
-#include <Corrade/Containers/Tags.h>
-
 #include "Magnum/Tags.h"
 
 #ifdef MAGNUM_BUILD_DEPRECATED

src/Magnum/MeshTools/Combine.cpp

@@ -59,8 +59,7 @@ Trade::MeshData combineIndexedImplementation(const MeshPrimitive primitive, Cont
 
     /* Allocate resulting attribute and vertex data and duplicate the
        attributes there according to the combined index buffer */
-    Containers::Array<char> vertexData{Containers::NoInit,
-        vertexStride*vertexCount};
+    Containers::Array<char> vertexData{NoInit, vertexStride*vertexCount};
     Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
     {
         std::size_t indexOffset = 0;
@@ -133,8 +132,7 @@ Trade::MeshData combineIndexedAttributes(const Containers::ArrayView<const Conta
         reading 32-bit values from odd addresses on some platforms) */
 
     /* Create a combined index array */
-    Containers::Array<char> combinedIndices{Containers::NoInit,
-        indexCount*indexStride};
+    Containers::Array<char> combinedIndices{NoInit, indexCount*indexStride};
     {
         std::size_t indexOffset = 0;
         for(const Trade::MeshData& mesh: data) {
@@ -177,8 +175,7 @@ Trade::MeshData combineFaceAttributes(const Trade::MeshData& mesh, const Trade::
     const UnsignedInt faceIndexSize = faceAttributes.isIndexed() ?
         meshIndexTypeSize(faceAttributes.indexType()) : 4;
     const UnsignedInt indexStride = meshIndexSize + faceIndexSize;
-    Containers::Array<char> combinedIndices{Containers::NoInit,
-        meshIndexCount*indexStride};
+    Containers::Array<char> combinedIndices{NoInit, meshIndexCount*indexStride};
     Utility::copy(mesh.indices(),
         Containers::StridedArrayView2D<char>{combinedIndices, {meshIndexCount, meshIndexSize}, {std::ptrdiff_t(indexStride), 1}});
 

src/Magnum/MeshTools/CompressIndices.cpp

@@ -127,7 +127,7 @@ Trade::MeshData compressIndices(Trade::MeshData&& data, MeshIndexType atLeast) {
     if(data.vertexDataFlags() & Trade::DataFlag::Owned)
         vertexData = data.releaseVertexData();
     else {
-        vertexData = Containers::Array<char>{Containers::NoInit, data.vertexData().size()};
+        vertexData = Containers::Array<char>{NoInit, data.vertexData().size()};
         Utility::copy(data.vertexData(), vertexData);
     }
 

src/Magnum/MeshTools/Concatenate.cpp

@@ -208,9 +208,9 @@ Trade::MeshData concatenate(const Containers::ArrayView<const Containers::Refere
        Index data are allocated with NoInit as the whole array will be written,
        however vertex data might have holes and thus it's zero-initialized. */
     const std::pair<UnsignedInt, UnsignedInt> indexVertexCount = Implementation::concatenateIndexVertexCount(meshes);
-    Containers::Array<char> indexData{Containers::NoInit,
+    Containers::Array<char> indexData{NoInit,
         indexVertexCount.first*sizeof(UnsignedInt)};
-    Containers::Array<char> vertexData{Containers::ValueInit,
+    Containers::Array<char> vertexData{ValueInit,
         attributeData.empty() ? 0 : (attributeData[0].stride()*indexVertexCount.second)};
     return Implementation::concatenate(std::move(indexData), indexVertexCount.second, std::move(vertexData), std::move(attributeData), meshes, "MeshTools::concatenate():");
 }

src/Magnum/MeshTools/Concatenate.h

@@ -106,7 +106,7 @@ template<template<class> class Allocator = Containers::ArrayAllocator> void conc
         indexData = destination.releaseIndexData();
         /* Everything is overwritten here so we don't need to zero-out the
            memory */
-        Containers::arrayResize<Allocator>(indexData, Containers::NoInit, indexVertexCount.first*sizeof(UnsignedInt));
+        Containers::arrayResize<Allocator>(indexData, NoInit, indexVertexCount.first*sizeof(UnsignedInt));
     }
 
     Containers::Array<Trade::MeshAttributeData> attributeData = Implementation::interleavedLayout(std::move(destination), {});
@@ -118,7 +118,7 @@ template<template<class> class Allocator = Containers::ArrayAllocator> void conc
            there, otherwise attributes that are not present in `meshes` would
            be garbage */
         Containers::arrayResize<Allocator>(vertexData, 0);
-        Containers::arrayResize<Allocator>(vertexData, Containers::ValueInit, attributeStride*indexVertexCount.second);
+        Containers::arrayResize<Allocator>(vertexData, ValueInit, attributeStride*indexVertexCount.second);
     }
 
     destination = Implementation::concatenate(std::move(indexData), indexVertexCount.second, std::move(vertexData), std::move(attributeData), meshes, "MeshTools::concatenateInto():");

src/Magnum/MeshTools/Duplicate.h

@@ -62,7 +62,7 @@ use @ref duplicateInto().
 @see @ref removeDuplicatesInPlace(), @ref combineIndexedAttributes()
 */
 template<class IndexType, class T> Containers::Array<T> duplicate(const Containers::StridedArrayView1D<const IndexType>& indices, const Containers::StridedArrayView1D<const T>& data) {
-    Containers::Array<T> out{Containers::NoInit, indices.size()};
+    Containers::Array<T> out{NoInit, indices.size()};
     duplicateInto<IndexType, T>(indices, data, out);
     return out;
 }

src/Magnum/MeshTools/GenerateIndices.cpp

@@ -76,7 +76,7 @@ void generateLineStripIndicesInto(const UnsignedInt vertexCount, const Container
 }
 
 Containers::Array<UnsignedInt> generateLineStripIndices(const UnsignedInt vertexCount) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, 2*(vertexCount - 1)};
+    Containers::Array<UnsignedInt> indices{NoInit, 2*(vertexCount - 1)};
     generateLineStripIndicesInto(vertexCount, indices);
     return indices;
 }
@@ -105,7 +105,7 @@ void generateLineLoopIndicesInto(const UnsignedInt vertexCount, const Containers
 }
 
 Containers::Array<UnsignedInt> generateLineLoopIndices(const UnsignedInt vertexCount) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, 2*vertexCount};
+    Containers::Array<UnsignedInt> indices{NoInit, 2*vertexCount};
     generateLineLoopIndicesInto(vertexCount, indices);
     return indices;
 }
@@ -134,7 +134,7 @@ void generateTriangleStripIndicesInto(const UnsignedInt vertexCount, const Conta
 }
 
 Containers::Array<UnsignedInt> generateTriangleStripIndices(const UnsignedInt vertexCount) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, 3*(vertexCount - 2)};
+    Containers::Array<UnsignedInt> indices{NoInit, 3*(vertexCount - 2)};
     generateTriangleStripIndicesInto(vertexCount, indices);
     return indices;
 }
@@ -164,7 +164,7 @@ void generateTriangleFanIndicesInto(const UnsignedInt vertexCount, const Contain
 }
 
 Containers::Array<UnsignedInt> generateTriangleFanIndices(const UnsignedInt vertexCount) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, 3*(vertexCount - 2)};
+    Containers::Array<UnsignedInt> indices{NoInit, 3*(vertexCount - 2)};
     generateTriangleFanIndicesInto(vertexCount, indices);
     return indices;
 }
@@ -216,14 +216,14 @@ template<class T> inline void generateQuadIndicesIntoImplementation(const Contai
 
 Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedInt>& quads) {
     /* We can skip zero-initialization here */
-    Containers::Array<UnsignedInt> out{Containers::NoInit, quads.size()*6/4};
+    Containers::Array<UnsignedInt> out{NoInit, quads.size()*6/4};
     generateQuadIndicesIntoImplementation(positions, quads, Containers::stridedArrayView(out));
     return out;
 }
 
 Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedShort>& quads) {
     /* Explicitly ensure we have the unused bytes zeroed out */
-    Containers::Array<UnsignedInt> out{Containers::ValueInit, quads.size()*6/4};
+    Containers::Array<UnsignedInt> out{ValueInit, quads.size()*6/4};
     generateQuadIndicesIntoImplementation(positions, quads,
         /* Could be just arrayCast<UnsignedShort>(stridedArrayView(out) on LE,
            but I want to be sure as much as possible that this compiles on BE
@@ -241,7 +241,7 @@ Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArra
 
 Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedByte>& quads) {
     /* Explicitly ensure we have the unused bytes zeroed out */
-    Containers::Array<UnsignedInt> out{Containers::ValueInit, quads.size()*6/4};
+    Containers::Array<UnsignedInt> out{ValueInit, quads.size()*6/4};
     generateQuadIndicesIntoImplementation(positions, quads,
         /* Could be just arrayCast<UnsignedShort>(stridedArrayView(out) on LE,
            but I want to be sure as much as possible that this compiles on BE
@@ -281,7 +281,7 @@ Trade::MeshData generateIndices(Trade::MeshData&& data) {
     if(data.vertexDataFlags() & Trade::DataFlag::Owned)
         vertexData = data.releaseVertexData();
     else {
-        vertexData = Containers::Array<char>{Containers::NoInit, data.vertexData().size()};
+        vertexData = Containers::Array<char>{NoInit, data.vertexData().size()};
         Utility::copy(data.vertexData(), vertexData);
     }
 
@@ -301,19 +301,19 @@ Trade::MeshData generateIndices(Trade::MeshData&& data) {
     Containers::Array<char> indexData;
     if(data.primitive() == MeshPrimitive::LineStrip) {
         primitive = MeshPrimitive::Lines;
-        indexData = Containers::Array<char>{Containers::NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)};
+        indexData = Containers::Array<char>{NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)};
         generateLineStripIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
     } else if(data.primitive() == MeshPrimitive::LineLoop) {
         primitive = MeshPrimitive::Lines;
-        indexData = Containers::Array<char>{Containers::NoInit, 2*vertexCount*sizeof(UnsignedInt)};
+        indexData = Containers::Array<char>{NoInit, 2*vertexCount*sizeof(UnsignedInt)};
         generateLineLoopIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
     } else if(data.primitive() == MeshPrimitive::TriangleStrip) {
         primitive = MeshPrimitive::Triangles;
-        indexData = Containers::Array<char>{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
+        indexData = Containers::Array<char>{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
         generateTriangleStripIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
     } else if(data.primitive() == MeshPrimitive::TriangleFan) {
         primitive = MeshPrimitive::Triangles;
-        indexData = Containers::Array<char>{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
+        indexData = Containers::Array<char>{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
         generateTriangleFanIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
     } else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateIndices(): invalid primitive" << data.primitive(),
         (Trade::MeshData{MeshPrimitive::Triangles, 0}));

src/Magnum/MeshTools/GenerateNormals.cpp

@@ -53,7 +53,7 @@ void generateFlatNormalsInto(const Containers::StridedArrayView1D<const Vector3>
 }
 
 Containers::Array<Vector3> generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>& positions) {
-    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
+    Containers::Array<Vector3> out{NoInit, positions.size()};
     generateFlatNormalsInto(positions, Containers::arrayView(out));
     return out;
 }
@@ -120,7 +120,7 @@ template<class T> inline void generateSmoothNormalsIntoImplementation(const Cont
     /* Turn that into a running offset array:
        triangleOffset[i + 1] - triangleOffset[i] is triangle count for vertex i
        triangleOffset[i] is offset into an triangle ID array for vertex i */
-    Containers::Array<UnsignedInt> triangleOffset{Containers::NoInit, positions.size() + 1};
+    Containers::Array<UnsignedInt> triangleOffset{NoInit, positions.size() + 1};
     triangleOffset[0] = 0;
     for(std::size_t i = 0; i != triangleCount.size(); ++i)
         triangleOffset[i + 1] = triangleOffset[i] + triangleCount[i];
@@ -130,7 +130,7 @@ template<class T> inline void generateSmoothNormalsIntoImplementation(const Cont
     /* Gather triangle IDs for every vertex. For vertex i,
        triangleIds[triangleOffset[i]] until triangleIds[triangleOffset[i + 1]]
        contains IDs of triangles that contain it. */
-    Containers::Array<T> triangleIds{Containers::NoInit, indices.size()};
+    Containers::Array<T> triangleIds{NoInit, indices.size()};
     for(std::size_t i = 0; i != indices.size(); ++i) {
         const T triangleId = i/3;
         const T vertexId = indices[i];
@@ -251,7 +251,7 @@ void generateSmoothNormalsInto(const Containers::StridedArrayView2D<const char>&
 namespace {
 
 template<class T> inline Containers::Array<Vector3> generateSmoothNormalsImplementation(const Containers::StridedArrayView1D<const T>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) {
-    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
+    Containers::Array<Vector3> out{NoInit, positions.size()};
     generateSmoothNormalsInto(indices, positions, out);
     return out;
 }
@@ -272,7 +272,7 @@ Containers::Array<Vector3> generateSmoothNormals(const Containers::StridedArrayV
 }
 
 Containers::Array<Vector3> generateSmoothNormals(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) {
-    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
+    Containers::Array<Vector3> out{NoInit, positions.size()};
     generateSmoothNormalsInto(indices, positions, out);
     return out;
 }

src/Magnum/MeshTools/Implementation/Tipsify.h

@@ -45,7 +45,7 @@ template<class T> void buildAdjacency(const Containers::StridedArrayView1D<const
        the end be in interval neighbors[neighborOffset[i]] ;
        neighbors[neighborOffset[i+1]]. Currently the values are shifted to
        right, because the next loop will shift them back left. */
-    neighborOffset = Containers::Array<UnsignedInt>{Containers::NoInit, vertexCount + 1};
+    neighborOffset = Containers::Array<UnsignedInt>{NoInit, vertexCount + 1};
     neighborOffset[0] = 0;
     UnsignedInt sum = 0;
     for(std::size_t i = 0; i != vertexCount; ++i) {
@@ -55,7 +55,7 @@ template<class T> void buildAdjacency(const Containers::StridedArrayView1D<const
 
     /* Array of neighbors, using (and changing) neighborOffset array for
        positioning */
-    neighbors = Containers::Array<UnsignedInt>{Containers::NoInit, sum};
+    neighbors = Containers::Array<UnsignedInt>{NoInit, sum};
     for(std::size_t i = 0; i != indices.size(); ++i)
         neighbors[neighborOffset[indices[i]+1]++] = i/3;
 }

src/Magnum/MeshTools/Interleave.cpp

@@ -216,7 +216,7 @@ Trade::MeshData interleavedLayout(Trade::MeshData&& data, const UnsignedInt vert
         return Trade::MeshData{data.primitive(), vertexCount};
 
     /* Allocate new data array */
-    Containers::Array<char> vertexData{Containers::NoInit, attributeData[0].stride()*vertexCount};
+    Containers::Array<char> vertexData{NoInit, attributeData[0].stride()*vertexCount};
 
     /* Convert the attributes from offset-only and zero vertex count to
        absolute, referencing the above-allocated data array */

src/Magnum/MeshTools/Interleave.h

@@ -160,7 +160,7 @@ template<class T, class ...U
 
     /* Create output buffer only if we have some attributes */
     if(attributeCount && attributeCount != ~std::size_t(0)) {
-        Containers::Array<char> data{Containers::ValueInit, attributeCount*stride};
+        Containers::Array<char> data{ValueInit, attributeCount*stride};
         Implementation::writeInterleaved(stride, data.begin(), first, next...);
 
         return data;

src/Magnum/MeshTools/Reference.cpp

@@ -67,7 +67,7 @@ Trade::MeshData owned(Trade::MeshData&& data) {
     /* Otherwise copy them, if the mesh is indexed. If not, the
        default-constructed instances are fine. */
     } else if(data.isIndexed()) {
-        indexData = Containers::Array<char>{Containers::NoInit, data.indexData().size()};
+        indexData = Containers::Array<char>{NoInit, data.indexData().size()};
         indices = Trade::MeshIndexData{data.indexType(), indexData.slice(data.indexOffset(), data.indexOffset() + data.indexCount()*meshIndexTypeSize(data.indexType()))};
         Utility::copy(data.indexData(), indexData);
     }
@@ -83,7 +83,7 @@ Trade::MeshData owned(Trade::MeshData&& data) {
 
     /* Otherwise copy them */
     } else {
-        vertexData = Containers::Array<char>{Containers::NoInit, originalVertexData.size()};
+        vertexData = Containers::Array<char>{NoInit, originalVertexData.size()};
         Utility::copy(originalVertexData, vertexData);
     }
 

src/Magnum/MeshTools/RemoveDuplicates.cpp

@@ -98,7 +98,7 @@ std::size_t removeDuplicatesInto(const Containers::StridedArrayView2D<const char
 }
 
 std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
+    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
     const std::size_t size = removeDuplicatesInto(data, indices);
     return {std::move(indices), size};
 }
@@ -156,7 +156,7 @@ std::size_t removeDuplicatesInPlaceInto(const Containers::StridedArrayView2D<cha
 }
 
 std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
+    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
     const std::size_t size = removeDuplicatesInPlaceInto(data, indices);
     return {std::move(indices), size};
 }
@@ -223,7 +223,7 @@ template<class IndexType, class T> std::size_t removeDuplicatesFuzzyIndexedInPla
        to be robust. */
     const std::size_t vectorSize = data.size()[1];
     T range = T(0.0);
-    Containers::Array<T> offsets{Containers::NoInit, vectorSize};
+    Containers::Array<T> offsets{NoInit, vectorSize};
     {
         /** @todo this isn't really cache-efficient, do differently */
         std::size_t i = 0;
@@ -249,8 +249,8 @@ template<class IndexType, class T> std::size_t removeDuplicatesFuzzyIndexedInPla
 
     /* Index array that'll be filled in each pass and then used for remapping
        the `indices`; discretized storage for all map keys. */
-    Containers::Array<UnsignedInt> remapping{Containers::NoInit, dataSize};
-    Containers::Array<std::size_t> discretized{Containers::NoInit, dataSize*vectorSize};
+    Containers::Array<UnsignedInt> remapping{NoInit, dataSize};
+    Containers::Array<std::size_t> discretized{NoInit, dataSize*vectorSize};
 
     /* First go with original coordinates, then move them by epsilon/2 in each
        dimension. */
@@ -349,7 +349,7 @@ template<class T> std::size_t removeDuplicatesFuzzyInPlaceIntoImplementation(con
 }
 
 template<class T> std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlaceImplementation(const Containers::StridedArrayView2D<T>& data, const T epsilon) {
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
+    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
     const std::size_t size = removeDuplicatesFuzzyInPlaceIntoImplementation(data, indices, epsilon);
     return {std::move(indices), size};
 }
@@ -425,7 +425,7 @@ Trade::MeshData removeDuplicates(Trade::MeshData&& data) {
         indexData = ownedInterleaved.releaseIndexData();
         indexType = ownedInterleaved.indexType();
     } else {
-        indexData = Containers::Array<char>{Containers::NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)};
+        indexData = Containers::Array<char>{NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)};
         uniqueVertexCount = removeDuplicatesInPlaceInto(vertexData, Containers::arrayCast<UnsignedInt>(indexData));
         indexType = MeshIndexType::UnsignedInt;
     }
@@ -435,7 +435,7 @@ Trade::MeshData removeDuplicates(Trade::MeshData&& data) {
         or interleave() above, arrayResize() wouldn't release the excessive
         memory in any way. This is basically equivalent to STL's
         shrink_to_fit(), which also copies */
-    Containers::Array<char> uniqueVertexData{Containers::NoInit, uniqueVertexCount*vertexData.size()[1]};
+    Containers::Array<char> uniqueVertexData{NoInit, uniqueVertexCount*vertexData.size()[1]};
     Utility::copy(vertexData.prefix(uniqueVertexCount),
         Containers::StridedArrayView2D<char>{uniqueVertexData, {uniqueVertexCount, vertexData.size()[1]}});
 

src/Magnum/MeshTools/Subdivide.h

@@ -64,8 +64,8 @@ vertices in the mesh is up to the user.
 template<class IndexType, class Vertex, class Interpolator> void subdivide(Containers::Array<IndexType>& indices, Containers::Array<Vertex>& vertices, Interpolator interpolator) {
     CORRADE_ASSERT(!(indices.size()%3), "MeshTools::subdivide(): index count is not divisible by 3", );
 
-    arrayResize(vertices, Containers::NoInit, vertices.size() + indices.size());
-    arrayResize(indices, Containers::NoInit, indices.size()*4);
+    arrayResize(vertices, NoInit, vertices.size() + indices.size());
+    arrayResize(indices, NoInit, indices.size()*4);
     subdivideInPlace(Containers::stridedArrayView(indices), Containers::stridedArrayView(vertices), interpolator);
 }
 

src/Magnum/MeshTools/Test/ConcatenateTest.cpp

@@ -379,9 +379,9 @@ void ConcatenateTest::concatenateInto() {
     Containers::Array<Trade::MeshAttributeData> attributeData{2};
     Containers::Array<char> vertexData;
     Containers::Array<char> indexData;
-    arrayResize(vertexData, Containers::DirectInit, (sizeof(Vector2) + sizeof(Vector3))*7, '\xff');
+    arrayResize(vertexData, DirectInit, (sizeof(Vector2) + sizeof(Vector3))*7, '\xff');
     arrayResize(vertexData, 0);
-    arrayResize(indexData, Containers::DirectInit, sizeof(UnsignedInt)*9, '\xff');
+    arrayResize(indexData, DirectInit, sizeof(UnsignedInt)*9, '\xff');
     arrayResize(indexData, 0);
     const void* attributeDataPointer = attributeData;
     const void* vertexDataPointer = vertexData;

src/Magnum/MeshTools/Test/FullScreenTriangleGLTest.cpp

@@ -133,12 +133,12 @@ void main() {
     using namespace Math::Literals;
 
     Image2D image = framebuffer.read({{}, Vector2i{4}}, PixelFormat::RGBA8Unorm);
-    CORRADE_COMPARE_AS(Containers::arrayCast<Color4ub>(image.data()), Containers::arrayView(Containers::Array<Color4ub>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(Containers::arrayCast<Color4ub>(image.data()), Containers::arrayView<Color4ub>({
         0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba,
         0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba,
         0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba,
         0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba, 0xff80ff80_rgba
-    }}), TestSuite::Compare::Container);
+    }), TestSuite::Compare::Container);
 }
 
 }}}}

src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp

@@ -366,11 +366,11 @@ void GenerateNormalsTest::smoothZeroAreaTriangle() {
     };
 
     CORRADE_COMPARE_AS(generateSmoothNormals(indices, positions),
-        (Containers::Array<Vector3>{Containers::InPlaceInit, {
+        Containers::arrayView<Vector3>({
             Vector3::zAxis(),
             Vector3::zAxis(),
             Vector3::zAxis()
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 }
 
 void GenerateNormalsTest::smoothNanPosition() {
@@ -442,7 +442,7 @@ void GenerateNormalsTest::benchmarkFlat() {
         Containers::stridedArrayView(BeveledCubeIndices),
         Containers::stridedArrayView(BeveledCubePositions));
 
-    Containers::Array<Vector3> normals{Containers::NoInit, positions.size()};
+    Containers::Array<Vector3> normals{NoInit, positions.size()};
     CORRADE_BENCHMARK(10) {
         generateFlatNormalsInto(positions, normals);
     }
@@ -451,7 +451,7 @@ void GenerateNormalsTest::benchmarkFlat() {
 }
 
 void GenerateNormalsTest::benchmarkSmooth() {
-    Containers::Array<Vector3> normals{Containers::NoInit, Containers::arraySize(BeveledCubePositions)};
+    Containers::Array<Vector3> normals{NoInit, Containers::arraySize(BeveledCubePositions)};
     CORRADE_BENCHMARK(10) {
         generateSmoothNormalsInto(BeveledCubeIndices, BeveledCubePositions, normals);
     }

src/Magnum/MeshTools/Test/InterleaveTest.cpp

@@ -233,7 +233,7 @@ void InterleaveTest::interleaveEmpty() {
 }
 
 void InterleaveTest::interleaveInto() {
-    Containers::Array<char> data{Containers::InPlaceInit, {
+    Containers::Array<char> data{InPlaceInit, {
         0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77,
         0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77,
         0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77, 0x11, 0x33, 0x55, 0x77,

src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp

@@ -441,7 +441,7 @@ template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceInto()
         {T(1.0), T(5.0)}
     };
 
-    Containers::Array<UnsignedInt> indices{Containers::NoInit, Containers::arraySize(data)};
+    Containers::Array<UnsignedInt> indices{NoInit, Containers::arraySize(data)};
     std::size_t result = MeshTools::removeDuplicatesFuzzyInPlaceInto(
             Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
             indices, T(2.0));

src/Magnum/MeshTools/Test/SubdivideTest.cpp

@@ -173,11 +173,11 @@ void SubdivideTest::benchmark() {
 
     CORRADE_BENCHMARK(3) {
         Containers::Array<UnsignedInt> indices;
-        arrayResize(indices, Containers::NoInit, icosphere.indexCount());
+        arrayResize(indices, NoInit, icosphere.indexCount());
         Utility::copy(icosphere.indices<UnsignedInt>(), indices);
 
         Containers::Array<Vector3> positions;
-        arrayResize(positions, Containers::NoInit, icosphere.vertexCount());
+        arrayResize(positions, NoInit, icosphere.vertexCount());
         Utility::copy(icosphere.attribute<Vector3>(Trade::MeshAttribute::Position), positions);
 
         /* Subdivide 5 times */

src/Magnum/MeshTools/Tipsify.cpp

@@ -49,7 +49,7 @@ template<class T> void tipsifyInPlaceImplementation(const Containers::StridedArr
     Containers::Array<UnsignedInt> deadEndStack;
 
     /* Output index buffer */
-    Containers::Array<T> outputIndices{Containers::NoInit, indices.size()};
+    Containers::Array<T> outputIndices{NoInit, indices.size()};
     std::size_t outputIndex = 0;
 
     /* Array with candidates for next fanning vertex (in 1-ring around

src/Magnum/MeshTools/sceneconverter.cpp

@@ -468,7 +468,7 @@ used.)")
                             break;
                     }
 
-                    arrayAppend(info.attributes, Containers::InPlaceInit,
+                    arrayAppend(info.attributes, InPlaceInit,
                         mesh->attributeOffset(k),
                         mesh->attributeStride(k),
                         mesh->attributeArraySize(k),

src/Magnum/Platform/AbstractXApplication.cpp

@@ -41,7 +41,7 @@ AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandle
     create(configuration, glConfiguration);
 }
 
-AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandler<GLConfiguration, Display*, VisualID, Window>* contextHandler, const Arguments& arguments, NoCreateT): _contextHandler{contextHandler}, _context{Containers::InPlaceInit, NoCreate, arguments.argc, arguments.argv}, _flags{Flag::Redraw} {}
+AbstractXApplication::AbstractXApplication(Implementation::AbstractContextHandler<GLConfiguration, Display*, VisualID, Window>* contextHandler, const Arguments& arguments, NoCreateT): _contextHandler{contextHandler}, _context{InPlaceInit, NoCreate, arguments.argc, arguments.argv}, _flags{Flag::Redraw} {}
 
 void AbstractXApplication::create() { create({}); }
 

src/Magnum/Platform/AndroidApplication.cpp

@@ -70,7 +70,7 @@ AndroidApplication::AndroidApplication(const Arguments& arguments, const Configu
     create(configuration, glConfiguration);
 }
 
-AndroidApplication::AndroidApplication(const Arguments& arguments, NoCreateT): _state{arguments}, _context{Containers::InPlaceInit, NoCreate} {
+AndroidApplication::AndroidApplication(const Arguments& arguments, NoCreateT): _state{arguments}, _context{InPlaceInit, NoCreate} {
     /* Redirect debug output to Android log */
     _logOutput.reset(new LogOutput);
 }

src/Magnum/Primitives/Circle.cpp

@@ -132,7 +132,7 @@ Trade::MeshData circle3DSolid(const UnsignedInt segments, const Circle3DFlags fl
     }
 
     /* Set up the layout */
-    Containers::Array<char> vertexData{Containers::NoInit, (segments + 2)*stride};
+    Containers::Array<char> vertexData{NoInit, (segments + 2)*stride};
     Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;

src/Magnum/Primitives/Icosphere.cpp

@@ -96,8 +96,8 @@ Trade::MeshData icosphereSolid(const UnsignedInt subdivisions) {
         Vector3 normal;
     };
     Containers::Array<char> vertexData;
-    Containers::arrayResize<Trade::ArrayAllocator>(vertexData,
-        Containers::NoInit, sizeof(Vertex)*vertexCount);
+    Containers::arrayResize<Trade::ArrayAllocator>(vertexData, NoInit,
+        sizeof(Vertex)*vertexCount);
 
     /* Build up the subdivided positions */
     {

src/Magnum/Primitives/Plane.cpp

@@ -76,7 +76,7 @@ Trade::MeshData planeSolid(const PlaneFlags flags) {
     }
 
     /* Set up the layout */
-    Containers::Array<char> vertexData{Containers::NoInit, 4*stride};
+    Containers::Array<char> vertexData{NoInit, 4*stride};
     Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
     std::size_t attributeIndex = 0;
     std::size_t attributeOffset = 0;

src/Magnum/ShaderTools/AbstractConverter.cpp

@@ -467,7 +467,7 @@ bool AbstractConverter::linkDataToFile(const std::initializer_list<std::pair<Sta
 }
 
 Containers::Array<char> AbstractConverter::linkDataToDataUsingInputFileCallbacks(const char* const prefix, const Containers::ArrayView<const std::pair<Stage, Containers::StringView>> filenames) {
-    Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, filenames.size()};
+    Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, filenames.size()};
 
     /* First load all files. Remember how many of these succeeded so we can
        close them again after */
@@ -573,7 +573,7 @@ bool AbstractConverter::doLinkFilesToFile(const Containers::ArrayView<const std:
 
         /** @todo merge the allocations once we have an ArrayTuple (actually,
             ideally it would merge also the nested allocations, how?) */
-        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, from.size()};
+        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, from.size()};
         for(std::size_t i = 0; i != from.size(); ++i)  {
             data[i].first = from[i].first;
             data[i].second = fileData[i];
@@ -652,7 +652,7 @@ Containers::Array<char> AbstractConverter::doLinkFilesToData(const Containers::A
         }
 
         /** @todo merge the allocations once we have an ArrayTuple */
-        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, filenames.size()};
+        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, filenames.size()};
         for(std::size_t i = 0; i != filenames.size(); ++i)  {
             data[i].first = filenames[i].first;
             data[i].second = fileData[i];

src/Magnum/ShaderTools/shaderconverter.cpp

@@ -208,7 +208,7 @@ void printSpirvInfo(Containers::ArrayView<const UnsignedInt> data) {
         Debug d;
         d << "Entrypoint" << entrypoint->name << "(" << Debug::nospace << spvExecutionModelToStage(entrypoint->executionModel) << Debug::nospace << ")" << Debug::newline;
 
-        Containers::Array<ShaderTools::Implementation::SpirvEntrypointInterface> interface{Containers::ValueInit, entrypoint->interfaces.size()};
+        Containers::Array<ShaderTools::Implementation::SpirvEntrypointInterface> interface{ValueInit, entrypoint->interfaces.size()};
         ShaderTools::Implementation::spirvEntrypointInterface(data, *entrypoint, interface);
         for(const ShaderTools::Implementation::SpirvEntrypointInterface& i: interface) {
             d << "   ";
@@ -433,11 +433,11 @@ see documentation of a particular converter for more information.)")
                 for(std::size_t i = 0; i != args.arrayValueCount("define"); ++i) {
                     const Containers::Array3<Containers::StringView> define =
                     args.arrayValue<Containers::StringView>("define", i).partition('=');
-                    arrayAppend(definitions, Containers::InPlaceInit,
+                    arrayAppend(definitions, InPlaceInit,
                         define[0], define[2]);
                 }
                 for(std::size_t i = 0; i != args.arrayValueCount("undefine"); ++i) {
-                    arrayAppend(definitions, Containers::InPlaceInit,
+                    arrayAppend(definitions, InPlaceInit,
                         args.arrayValue<Containers::StringView>("undefine", i), nullptr);
                 }
 
@@ -465,7 +465,7 @@ see documentation of a particular converter for more information.)")
             if(args.isSet("link")) {
                 arrayReserve(linkInputs, args.arrayValueCount("input"));
                 for(std::size_t i = 0; i != args.arrayValueCount("input"); ++i)
-                    arrayAppend(linkInputs, Containers::InPlaceInit,
+                    arrayAppend(linkInputs, InPlaceInit,
                         ShaderTools::Stage::Unspecified, args.arrayValue<Containers::StringView>("input", i));
             }
         }

src/Magnum/Shaders/Phong.cpp

@@ -260,11 +260,11 @@ Phong::Phong(const Flags flags, const UnsignedInt lightCount): _flags{flags}, _l
         setShininess(80.0f);
         if(flags & Flag::NormalTexture)
             setNormalTextureScale(1.0f);
-        setLightPositions(Containers::Array<Vector4>{Containers::DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}});
-        Containers::Array<Magnum::Color3> colors{Containers::DirectInit, lightCount, Magnum::Color3{1.0f}};
+        setLightPositions(Containers::Array<Vector4>{DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}});
+        Containers::Array<Magnum::Color3> colors{DirectInit, lightCount, Magnum::Color3{1.0f}};
         setLightColors(colors);
         setLightSpecularColors(colors);
-        setLightRanges(Containers::Array<Float>{Containers::DirectInit, lightCount, Constants::inf()});
+        setLightRanges(Containers::Array<Float>{DirectInit, lightCount, Constants::inf()});
         /* Light position is zero by default */
         setNormalMatrix(Matrix3x3{Math::IdentityInit});
     }
@@ -390,7 +390,7 @@ Phong& Phong::setLightPositions(const std::initializer_list<Vector4> positions)
 
 #ifdef MAGNUM_BUILD_DEPRECATED
 Phong& Phong::setLightPositions(const Containers::ArrayView<const Vector3> positions) {
-    Containers::Array<Vector4> fourComponent{Containers::NoInit, positions.size()};
+    Containers::Array<Vector4> fourComponent{NoInit, positions.size()};
     for(std::size_t i = 0; i != positions.size(); ++i)
         fourComponent[i] = Vector4{positions[i], 0.0f};
     setLightPositions(fourComponent);
@@ -431,7 +431,7 @@ Phong& Phong::setLightColors(const Containers::ArrayView<const Magnum::Color3> c
 
 #ifdef MAGNUM_BUILD_DEPRECATED
 Phong& Phong::setLightColors(const Containers::ArrayView<const Magnum::Color4> colors) {
-    Containers::Array<Magnum::Color3> threeComponent{Containers::NoInit, colors.size()};
+    Containers::Array<Magnum::Color3> threeComponent{NoInit, colors.size()};
     for(std::size_t i = 0; i != colors.size(); ++i)
         threeComponent[i] = colors[i].rgb();
     setLightColors(threeComponent);

src/Magnum/Shaders/Test/FlatGLTest.cpp

@@ -775,7 +775,7 @@ template<class T> void FlatGLTest::renderVertexColor2D() {
         Primitives::Circle2DFlag::TextureCoordinates);
 
     /* Highlight a quarter */
-    Containers::Array<T> colorData{Containers::DirectInit, circleData.vertexCount(), 0x999999_rgbf};
+    Containers::Array<T> colorData{DirectInit, circleData.vertexCount(), 0x999999_rgbf};
     for(std::size_t i = 8; i != 16; ++i)
         colorData[i + 1] = 0xffff99_rgbf*1.5f;
 
@@ -829,7 +829,7 @@ template<class T> void FlatGLTest::renderVertexColor3D() {
         Primitives::UVSphereFlag::TextureCoordinates);
 
     /* Highlight the middle rings */
-    Containers::Array<T> colorData{Containers::DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
+    Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
     for(std::size_t i = 6*33; i != 9*33; ++i)
         colorData[i + 1] = 0xffff99_rgbf*1.5f;
 

src/Magnum/Shaders/Test/PhongGLTest.cpp

@@ -353,7 +353,7 @@ const struct {
     {"directional", "light-directional.tga",
         {1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
         1.0f, Constants::inf(),
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Ambient isn't affected by light direction, otherwise it's a
                dot product of a normalized direction */
             {{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())},
@@ -380,7 +380,7 @@ const struct {
     {"directional, from back", "light-none.tga",
         {-1.0f, 1.5f, -0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
         1.0f, Constants::inf(),
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Only ambient color left */
             {{40, 40}, 0x222222_rgb}
         }}},
@@ -389,13 +389,13 @@ const struct {
     {"directional, intensity=2", "light-directional-intensity2.tga",
         {1.0f, -1.5f, 0.5f, 0.0f}, Color3{1.0f}, Color3{1.0f},
         2.0f, 1.0f,
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             {{40, 40}, 0x222222_rgb + 0xff8080_rgb*dot(Vector3{1.0f, -1.5f, 0.5f}.normalized(), Vector3::zAxis())*2.0f}
         }}},
     {"point", "light-point.tga",
         {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, Color3{1.0f},
         1.0f, Constants::inf(),
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* The range is inf, so it doesn't get fully ambient even at the
                edge */
             {{8, 71}, 0x2c2727_rgb},
@@ -407,21 +407,21 @@ const struct {
     {"point, specular material color", "light-point-specular-color.tga",
         {0.75f, -0.75f, -0.75f, 1.0f}, 0x80ff80_rgbf, Color3{1.0f},
         1.0f, Constants::inf(),
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Colored specular highlight */
             {{60, 19}, 0xc27573_rgb}
         }}},
     {"point, specular light color", "light-point-specular-color.tga",
         {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf,
         1.0f, Constants::inf(),
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Colored specular highlight */
             {{60, 19}, 0xc27573_rgb}
         }}},
     {"point, attenuated specular", "light-point-attenuated-specular.tga",
         {1.0f, -1.0f, -0.25f, 1.0f}, Color3{1.0f}, Color3{1.0f},
         1.0f, 2.5f,
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Specular highlight shouldn't be brighter than the attenuated
                intensity */
             {{57, 22}, 0xa68787_rgb}
@@ -429,7 +429,7 @@ const struct {
     {"point, range=1.5, specular color", "light-point-range1.5.tga",
         {0.75f, -0.75f, -0.75f, 1.0f}, Color3{1.0f}, 0x80ff80_rgbf,
         1.0f, 1.5f,
-        {Containers::InPlaceInit, {
+        {InPlaceInit, {
             /* Color goes back to ambient at distance = 1.5 */
             {{59, 60}, 0x222222_rgb},
             {{29, 50}, 0x222222_rgb},
@@ -1071,7 +1071,7 @@ void PhongGLTest::renderTexturedNormal() {
         Vector3 bitangent;
     } tangentBitangent{data.tangent, data.bitangent};
     GL::Buffer tangents;
-    tangents.setData(Containers::Array<TangentBitangent>{Containers::DirectInit, 4, tangentBitangent});
+    tangents.setData(Containers::Array<TangentBitangent>{DirectInit, 4, tangentBitangent});
     plane.addVertexBuffer(tangents, 0, sizeof(TangentBitangent),
         GL::DynamicAttribute{Shaders::Phong::Tangent4{data.tangentComponents}});
     plane.addVertexBuffer(std::move(tangents), sizeof(Vector4),
@@ -1148,7 +1148,7 @@ template<class T> void PhongGLTest::renderVertexColor() {
         Primitives::UVSphereFlag::TextureCoordinates);
 
     /* Highlight the pole vertices and the middle rings */
-    Containers::Array<T> colorData{Containers::DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
+    Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0x999999_rgbf};
     for(std::size_t i = 0; i != 3*33 + 1; ++i)
         colorData[sphereData.vertexCount()  - i - 1] = 0xff0000_rgbf*5.0f;
     for(std::size_t i = 6*33; i != 9*33; ++i)

src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@@ -200,7 +200,7 @@ template<class T> void VertexColorGLTest::renderDefaults2D() {
         Primitives::Circle2DFlag::TextureCoordinates);
 
     /* All a single color */
-    Containers::Array<T> colorData{Containers::DirectInit, circleData.vertexCount(), 0xffffff_rgbf};
+    Containers::Array<T> colorData{DirectInit, circleData.vertexCount(), 0xffffff_rgbf};
 
     GL::Buffer colors;
     colors.setData(colorData);
@@ -241,7 +241,7 @@ template<class T> void VertexColorGLTest::renderDefaults3D() {
         Primitives::UVSphereFlag::TextureCoordinates);
 
     /* All a single color */
-    Containers::Array<T> colorData{Containers::DirectInit, sphereData.vertexCount(), 0xffffff_rgbf};
+    Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0xffffff_rgbf};
 
     GL::Buffer colors;
     colors.setData(colorData);
@@ -274,7 +274,7 @@ template<class T> void VertexColorGLTest::render2D() {
         Primitives::Circle2DFlag::TextureCoordinates);
 
     /* Highlight a quarter */
-    Containers::Array<T> colorData{Containers::DirectInit, circleData.vertexCount(), 0x9999ff_rgbf};
+    Containers::Array<T> colorData{DirectInit, circleData.vertexCount(), 0x9999ff_rgbf};
     for(std::size_t i = 8; i != 16; ++i)
         colorData[i + 1] = 0xffff99_rgbf;
 
@@ -319,7 +319,7 @@ template<class T> void VertexColorGLTest::render3D() {
         Primitives::UVSphereFlag::TextureCoordinates);
 
     /* Highlight the middle rings */
-    Containers::Array<T> colorData{Containers::DirectInit, sphereData.vertexCount(), 0x9999ff_rgbf};
+    Containers::Array<T> colorData{DirectInit, sphereData.vertexCount(), 0x9999ff_rgbf};
     for(std::size_t i = 6*33; i != 9*33; ++i)
         colorData[i + 1] = 0xffff99_rgbf;
 

src/Magnum/Tags.h

@@ -29,7 +29,7 @@
  * @brief Tag type @ref Magnum::NoInitT, @ref Magnum::NoCreateT, tag @ref Magnum::NoInit, @ref Magnum::NoCreate
  */
 
-#include <Corrade/Containers/Tags.h>
+#include <Corrade/Tags.h>
 
 #include "Magnum/configure.h"
 
@@ -42,7 +42,11 @@ namespace Magnum {
 Used to distinguish construction with no initialization at all.
 @see @ref NoInit
 */
-typedef Corrade::Containers::NoInitT NoInitT;
+#ifdef DOXYGEN_GENERATING_OUTPUT
+typedef Corrade::NoInitT NoInitT;
+#else
+using Corrade::NoInitT;
+#endif
 
 /**
 @brief No creation tag type
@@ -51,7 +55,11 @@ Used to distinguish construction without creating the underlying OpenGL /
 Vulkan / ... object.
 @see @ref NoCreate
 */
-typedef Corrade::Containers::NoCreateT NoCreateT;
+#ifdef DOXYGEN_GENERATING_OUTPUT
+typedef Corrade::NoCreateT NoCreateT;
+#else
+using Corrade::NoCreateT;
+#endif
 
 /**
 @brief No allocation tag type
@@ -77,7 +85,7 @@ Use for construction with no initialization at all.
 #ifdef DOXYGEN_GENERATING_OUTPUT
 constexpr NoInitT NoInit{};
 #else
-using Corrade::Containers::NoInit;
+using Corrade::NoInit;
 #endif
 
 /**
@@ -92,7 +100,7 @@ overhead), wrap the objects in an @ref Corrade::Containers::Optional.
 #ifdef DOXYGEN_GENERATING_OUTPUT
 constexpr NoCreateT NoCreate{};
 #else
-using Corrade::Containers::NoCreate;
+using Corrade::NoCreate;
 #endif
 
 /**

src/Magnum/Test/CMakeLists.txt

@@ -31,7 +31,8 @@ corrade_add_test(PixelFormatTest PixelFormatTest.cpp LIBRARIES MagnumTestLib)
 corrade_add_test(PixelStorageTest PixelStorageTest.cpp LIBRARIES Magnum)
 corrade_add_test(ResourceManagerTest ResourceManagerTest.cpp LIBRARIES Magnum)
 corrade_add_test(SamplerTest SamplerTest.cpp LIBRARIES MagnumTestLib)
-corrade_add_test(TagsTest TagsTest.cpp LIBRARIES Magnum)
+# Prefixed with project name to avoid conflicts with TagsTest in Corrade
+corrade_add_test(MagnumTagsTest TagsTest.cpp LIBRARIES Magnum)
 
 # Prefixed with project name to avoid conflicts with VersionTest in Corrade and
 # other repos
@@ -47,7 +48,7 @@ set_target_properties(
     PixelStorageTest
     ResourceManagerTest
     SamplerTest
-    TagsTest
+    MagnumTagsTest
     MagnumVersionTest
     VertexFormatTest
     PROPERTIES FOLDER "Magnum/Test")

src/Magnum/Test/ImageTest.cpp

@@ -743,7 +743,7 @@ void ImageTest::pixels1D() {
             .setAlignment(1) /** @todo alignment 4 expects 17 bytes. what */
             .setSkip({3, 0, 0}),
         PixelFormat::RGB8Unorm, 2,
-        Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::Array<char>{InPlaceInit, {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 8
         }}};
     const Image1D& cimage = image;
@@ -772,7 +772,7 @@ void ImageTest::pixels2D() {
             .setSkip({3, 2, 0})
             .setRowLength(6),
         PixelFormat::RGB8Unorm, {2, 4},
-        Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::Array<char>{InPlaceInit, {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0,
@@ -807,7 +807,7 @@ void ImageTest::pixels3D() {
             .setRowLength(6)
             .setImageHeight(7),
         PixelFormat::RGB8Unorm, {2, 4, 3},
-        Containers::Array<char>{Containers::InPlaceInit, {
+        Containers::Array<char>{InPlaceInit, {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

src/Magnum/Test/ResourceManagerTest.cpp

@@ -457,7 +457,7 @@ void ResourceManagerTest::loader() {
 
     {
         ResourceManager rm;
-        Containers::Pointer<IntResourceLoader> loaderPtr{Containers::InPlaceInit, rm};
+        Containers::Pointer<IntResourceLoader> loaderPtr{InPlaceInit, rm};
         IntResourceLoader& loader = *loaderPtr;
         rm.setLoader<Int>(std::move(loaderPtr));
 
@@ -507,7 +507,7 @@ void ResourceManagerTest::loaderSetNullptr() {
     };
 
     ResourceManager rm;
-    Containers::Pointer<IntResourceLoader> loaderPtr{Containers::InPlaceInit};
+    Containers::Pointer<IntResourceLoader> loaderPtr{InPlaceInit};
     IntResourceLoader& loader = *loaderPtr;
     rm.setLoader<Int>(std::move(loaderPtr));
 

src/Magnum/Text/Test/AbstractFontConverterTest.cpp

@@ -507,7 +507,7 @@ void AbstractFontConverterTest::exportGlyphCacheToSingleData() {
 
     Containers::Array<char> out = converter.exportGlyphCacheToSingleData(dummyGlyphCache);
     CORRADE_COMPARE_AS(out,
-        (Containers::Array<char>{Containers::InPlaceInit, {'\xee'}}),
+        (Containers::Array<char>{InPlaceInit, {'\xee'}}),
         TestSuite::Compare::Container);
 }
 
@@ -640,7 +640,7 @@ void AbstractFontConverterTest::exportGlyphCacheToDataThroughSingleData() {
     CORRADE_COMPARE(ret.size(), 1);
     CORRADE_COMPARE(ret[0].first, "font.out");
     CORRADE_COMPARE_AS(ret[0].second,
-        (Containers::Array<char>{Containers::InPlaceInit, {'\xee'}}),
+        (Containers::Array<char>{InPlaceInit, {'\xee'}}),
         TestSuite::Compare::Container);
 }
 
@@ -730,8 +730,8 @@ void AbstractFontConverterTest::exportGlyphCacheToFileThroughData() {
 
         std::vector<std::pair<std::string, Containers::Array<char>>> doExportGlyphCacheToData(AbstractGlyphCache&, const std::string& filename) const override {
             std::vector<std::pair<std::string, Containers::Array<char>>> ret;
-            ret.emplace_back(filename, Containers::Array<char>{Containers::InPlaceInit, {'\xf0'}});
-            ret.emplace_back(filename + ".dat", Containers::Array<char>{Containers::InPlaceInit, {'\xfe', '\xed'}});
+            ret.emplace_back(filename, Containers::Array<char>{InPlaceInit, {'\xf0'}});
+            ret.emplace_back(filename + ".dat", Containers::Array<char>{InPlaceInit, {'\xfe', '\xed'}});
             return ret;
         }
     } converter;

src/Magnum/Text/Test/RendererGLTest.cpp

@@ -192,7 +192,7 @@ void RendererGLTest::renderMesh() {
     /* Vertex buffer contents */
     Containers::Array<char> vertices = vertexBuffer.data();
     CORRADE_COMPARE_AS(Containers::arrayCast<const Float>(vertices),
-        (Containers::Array<Float>{Containers::InPlaceInit, {
+        Containers::arrayView<Float>({
             0.0f + offset.x(),  0.5f + offset.y(), 0.0f, 10.0f,
             0.0f + offset.x(),  0.0f + offset.y(), 0.0f,  0.0f,
             0.75f + offset.x(), 0.5f + offset.y(), 6.0f, 10.0f,
@@ -207,15 +207,15 @@ void RendererGLTest::renderMesh() {
             2.75f + offset.x(), -0.5f + offset.y(), 12.0f,  0.0f,
             5.0f + offset.x(),   1.0f + offset.y(), 18.0f, 10.0f,
             5.0f + offset.x(),  -0.5f + offset.y(), 18.0f,  0.0f
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 
     Containers::Array<char> indices = indexBuffer.data();
     CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(indices),
-        (Containers::Array<UnsignedByte>{Containers::InPlaceInit, {
+        Containers::arrayView<UnsignedByte>({
             0,  1,  2,  1,  3,  2,
             4,  5,  6,  5,  7,  6,
             8,  9, 10,  9, 11, 10
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
     #endif
 }
 
@@ -236,11 +236,11 @@ void RendererGLTest::renderMeshIndexType() {
     CORRADE_COMPARE(vertexBuffer.size(), 256*(2 + 2)*4);
     CORRADE_COMPARE(indicesByte.size(), 64*6);
     CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(indicesByte).prefix(18),
-        (Containers::Array<UnsignedByte>{Containers::InPlaceInit, {
+        Containers::arrayView<UnsignedByte>({
             0,  1,  2,  1,  3,  2,
             4,  5,  6,  5,  7,  6,
             8,  9, 10,  9, 11, 10
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 
     /* 16-bit indices (260 vertices) */
     std::tie(mesh, std::ignore) = Text::Renderer3D::render(font, nullGlyphCache,
@@ -250,11 +250,11 @@ void RendererGLTest::renderMeshIndexType() {
     CORRADE_COMPARE(vertexBuffer.size(), 260*(2 + 2)*4);
     CORRADE_COMPARE(indicesShort.size(), 65*6*2);
     CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedShort>(indicesShort).prefix(18),
-        (Containers::Array<UnsignedShort>{Containers::InPlaceInit, {
+        Containers::arrayView<UnsignedShort>({
             0,  1,  2,  1,  3,  2,
             4,  5,  6,  5,  7,  6,
             8,  9, 10,  9, 11, 10
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
     #else
     CORRADE_SKIP("Can't verify buffer contents on OpenGL ES.");
     #endif
@@ -284,12 +284,12 @@ void RendererGLTest::mutableText() {
     #ifndef MAGNUM_TARGET_GLES
     Containers::Array<char> indices = renderer.indexBuffer().data();
     CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(indices).prefix(24),
-        (Containers::Array<UnsignedByte>{Containers::InPlaceInit, {
+        Containers::arrayView<UnsignedByte>({
              0,  1,  2,  1,  3,  2,
              4,  5,  6,  5,  7,  6,
              8,  9, 10,  9, 11, 10,
             12, 13, 14, 13, 15, 14
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
     #endif
 
     /* Render text */
@@ -305,7 +305,7 @@ void RendererGLTest::mutableText() {
     #ifndef MAGNUM_TARGET_GLES
     Containers::Array<char> vertices = renderer.vertexBuffer().data();
     CORRADE_COMPARE_AS(Containers::arrayCast<const Float>(vertices).prefix(48),
-        (Containers::Array<Float>{Containers::InPlaceInit, {
+        Containers::arrayView<Float>({
             0.0f,  0.5f, 0.0f, 10.0f,
             0.0f,  0.0f, 0.0f,  0.0f,
             0.75f, 0.5f, 6.0f, 10.0f,
@@ -320,7 +320,7 @@ void RendererGLTest::mutableText() {
             2.75f, -0.5f, 12.0f,  0.0f,
             5.0f,   1.0f, 18.0f, 10.0f,
             5.0f,  -0.5f, 18.0f,  0.0f
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
     #endif
 }
 

src/Magnum/Trade/Implementation/converterUtilities.h

@@ -57,7 +57,7 @@ Containers::Array<ImageInfo> imageInfo(AbstractImporter& importer, bool& error,
                 error = true;
                 continue;
             }
-            arrayAppend(infos, Containers::InPlaceInit, i, j,
+            arrayAppend(infos, InPlaceInit, i, j,
                 image->isCompressed(),
                 image->isCompressed() ?
                     PixelFormat{} : image->format(),
@@ -78,7 +78,7 @@ Containers::Array<ImageInfo> imageInfo(AbstractImporter& importer, bool& error,
                 error = true;
                 continue;
             }
-            arrayAppend(infos, Containers::InPlaceInit, i, j,
+            arrayAppend(infos, InPlaceInit, i, j,
                 image->isCompressed(),
                 image->isCompressed() ?
                     PixelFormat{} : image->format(),
@@ -99,7 +99,7 @@ Containers::Array<ImageInfo> imageInfo(AbstractImporter& importer, bool& error,
                 error = true;
                 continue;
             }
-            arrayAppend(infos, Containers::InPlaceInit, i, j,
+            arrayAppend(infos, InPlaceInit, i, j,
                 image->isCompressed(),
                 image->isCompressed() ?
                     PixelFormat{} : image->format(),

src/Magnum/Trade/Test/AnimationDataTest.cpp

@@ -116,7 +116,7 @@ void AnimationDataTest::constructTrackData() {
             nullptr,
             Animation::Interpolation::Linear,
             animationInterpolatorFor<Vector3>(Animation::Interpolation::Linear)}};
-    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{Containers::InPlaceInit, {trackData}}};
+    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{InPlaceInit, {trackData}}};
     CORRADE_COMPARE(data.trackType(0), AnimationTrackType::Vector3);
     CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3);
     CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D);
@@ -133,7 +133,7 @@ void AnimationDataTest::constructTrackDataResultType() {
             nullptr,
             Animation::Interpolation::Linear,
             animationInterpolatorFor<CubicHermite3D>(Animation::Interpolation::Linear)}};
-    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{Containers::InPlaceInit, {trackData}}};
+    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{InPlaceInit, {trackData}}};
     CORRADE_COMPARE(data.trackType(0), AnimationTrackType::CubicHermite3D);
     CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3);
     CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D);
@@ -148,7 +148,7 @@ void AnimationDataTest::constructTrackDataTemplate() {
             nullptr,
             Animation::Interpolation::Linear,
             animationInterpolatorFor<CubicHermite3D>(Animation::Interpolation::Linear)}};
-    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{Containers::InPlaceInit, {trackData}}};
+    AnimationData data{nullptr, Containers::Array<AnimationTrackData>{InPlaceInit, {trackData}}};
     CORRADE_COMPARE(data.trackType(0), AnimationTrackType::CubicHermite3D);
     CORRADE_COMPARE(data.trackResultType(0), AnimationTrackType::Vector3);
     CORRADE_COMPARE(data.trackTargetType(0), AnimationTrackTargetType::Translation3D);

src/Magnum/Trade/Test/MaterialDataTest.cpp

@@ -888,7 +888,7 @@ void MaterialDataTest::constructDuplicateAttribute() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    auto attributes = Containers::Array<MaterialAttributeData>{Containers::InPlaceInit, {
+    Containers::Array<MaterialAttributeData> attributes{InPlaceInit, {
         {MaterialAttribute::DoubleSided, true},
         {MaterialAttribute::DiffuseTextureCoordinates, 5u},
         {"highlightColor", 0x335566ff_rgbaf},

src/Magnum/Trade/Test/SkinDataTest.cpp

@@ -125,8 +125,8 @@ void SkinDataTest::constructMove() {
 }
 
 void SkinDataTest::release() {
-    Containers::Array<UnsignedInt> joints{Containers::InPlaceInit, {0, 2, 3}};
-    Containers::Array<Matrix3> inverseBindMatrices{Containers::InPlaceInit, {
+    Containers::Array<UnsignedInt> joints{InPlaceInit, {0, 2, 3}};
+    Containers::Array<Matrix3> inverseBindMatrices{InPlaceInit, {
         Matrix3::translation(Vector2::yAxis(0.0f)),
         Matrix3::translation(Vector2::yAxis(2.0f)),
         Matrix3::translation(Vector2::yAxis(4.0f))

src/Magnum/Vk/DescriptorPool.cpp

@@ -48,7 +48,7 @@ DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(const UnsignedInt maxSets, co
 
     Containers::ArrayView<VkDescriptorPoolSize> poolSizesCopy;
     _data = Containers::ArrayTuple{
-        {Containers::NoInit, poolSizes.size(), poolSizesCopy}
+        {NoInit, poolSizes.size(), poolSizesCopy}
     };
     for(std::size_t i = 0; i != poolSizes.size(); ++i) {
         CORRADE_ASSERT(poolSizes[i].second,

src/Magnum/Vk/DescriptorSetLayout.cpp

@@ -46,7 +46,7 @@ DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding
 DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding, const DescriptorType descriptorType, const Containers::ArrayView<const VkSampler> immutableSamplers, const ShaderStages stages, Flags flags): _binding{}, _flags{VkDescriptorBindingFlags(flags)} {
     Containers::ArrayView<VkSampler> immutableSamplersCopy;
     _data = Containers::ArrayTuple{
-        {Containers::NoInit, immutableSamplers.size(), immutableSamplersCopy}
+        {NoInit, immutableSamplers.size(), immutableSamplersCopy}
     };
     Utility::copy(immutableSamplers, immutableSamplersCopy);
 
@@ -109,10 +109,10 @@ DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(const Containers::A
     Containers::ArrayView<VkDescriptorSetLayoutBindingFlagsCreateInfo> bindingsCreateInfoView;
     Containers::ArrayView<VkSampler> immutableSamplersCopy;
     _data = Containers::ArrayTuple{
-        {Containers::NoInit, bindings.size(), bindingsCopy},
-        {Containers::NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy},
-        {Containers::ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView},
-        {Containers::NoInit, immutableSamplerCount, immutableSamplersCopy}
+        {NoInit, bindings.size(), bindingsCopy},
+        {NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy},
+        {ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView},
+        {NoInit, immutableSamplerCount, immutableSamplersCopy}
     };
 
     /* Copy the binding and then for each manually copy and reroute the

src/Magnum/Vk/Device.cpp

@@ -120,7 +120,7 @@ struct DeviceCreateInfo::State {
     DeviceProperties properties{NoCreate};
 };
 
-DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{Containers::InPlaceInit} {
+DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{InPlaceInit} {
     Utility::Arguments args = Implementation::arguments();
     args.parse(deviceProperties._instance->state().argc, deviceProperties._instance->state().argv);
 
@@ -307,7 +307,7 @@ DeviceCreateInfo& DeviceCreateInfo::addEnabledExtensions(const Containers::Array
            don't get invalidated when the array gets reallocated. */
         const char* data;
         if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
-            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
+            data = arrayAppend(_state->ownedStrings, InPlaceInit,
                 Containers::AllocatedInit, extension).data();
         else data = extension.data();
 

src/Magnum/Vk/DeviceProperties.cpp

@@ -379,7 +379,7 @@ Containers::ArrayView<const VkQueueFamilyProperties2> DeviceProperties::queueFam
         UnsignedInt count;
         _state->getQueueFamilyPropertiesImplementation(*this, count, nullptr);
 
-        _state->queueFamilyProperties = Containers::Array<VkQueueFamilyProperties2>{Containers::ValueInit, count};
+        _state->queueFamilyProperties = Containers::Array<VkQueueFamilyProperties2>{ValueInit, count};
         for(VkQueueFamilyProperties2& i: _state->queueFamilyProperties)
             i.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
         _state->getQueueFamilyPropertiesImplementation(*this, count, _state->queueFamilyProperties);
@@ -587,7 +587,7 @@ Containers::Array<DeviceProperties> enumerateDevices(Instance& instance) {
 
     /* Fetch device handles, expect the device count didn't change between
        calls */
-    Containers::Array<DeviceProperties> out{Containers::NoInit, count};
+    Containers::Array<DeviceProperties> out{NoInit, count};
     CORRADE_INTERNAL_ASSERT_OUTPUT(Implementation::enumerateDevicesInto(instance, out) == out.size());
 
     return out;
@@ -599,7 +599,7 @@ Containers::Optional<DeviceProperties> tryPickDevice(Instance& instance) {
 
     /* Pick the first by default */
     if(args.value("device").empty()) {
-        Containers::Array1<DeviceProperties> devices{Containers::NoInit};
+        Containers::Array1<DeviceProperties> devices{NoInit};
         if(!Implementation::enumerateDevicesInto(instance, devices)) {
             Error{} << "Vk::tryPickDevice(): no Vulkan devices found";
             return {};
@@ -611,7 +611,7 @@ Containers::Optional<DeviceProperties> tryPickDevice(Instance& instance) {
     /* Pick by ID */
     if(args.value("device")[0] >= '0' && args.value("device")[0] <= '9') {
         const UnsignedInt id = args.value<UnsignedInt>("device");
-        Containers::Array<DeviceProperties> devices{Containers::NoInit, id + 1};
+        Containers::Array<DeviceProperties> devices{NoInit, id + 1};
         const UnsignedInt count = Implementation::enumerateDevicesInto(instance, devices);
         if(id >= count) {
             Error{} << "Vk::tryPickDevice(): index" << id << "out of bounds for" << count << "Vulkan devices";

src/Magnum/Vk/Framebuffer.cpp

@@ -40,7 +40,7 @@ struct FramebufferCreateInfo::State {
     Containers::Array<VkImageView> attachments;
 };
 
-FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, const Containers::ArrayView<const Containers::Reference<ImageView>> attachments, const Vector3i& size, const Flags flags): _info{}, _state{Containers::InPlaceInit} {
+FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, const Containers::ArrayView<const Containers::Reference<ImageView>> attachments, const Vector3i& size, const Flags flags): _info{}, _state{InPlaceInit} {
     _info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     _info.flags = VkFramebufferCreateFlags(flags);
     _info.renderPass = renderPass;
@@ -52,7 +52,7 @@ FramebufferCreateInfo::FramebufferCreateInfo(const VkRenderPass renderPass, cons
     /** @todo combine the state and array allocations into one (could use
         ArrayTuple, however that one includes ArrayView so not much better than
         including Array directly in the header which I don't want to do) */
-    _state->attachments = Containers::Array<VkImageView>{Containers::NoInit, attachments.size()};
+    _state->attachments = Containers::Array<VkImageView>{NoInit, attachments.size()};
     for(std::size_t i = 0; i != attachments.size(); ++i)
         _state->attachments[i] = *attachments[i];
     _info.attachmentCount = _state->attachments.size();

src/Magnum/Vk/Implementation/DriverWorkaround.cpp

@@ -100,13 +100,13 @@ void disableWorkaround(Containers::Array<std::pair<Containers::StringView, bool>
         return;
     }
 
-    arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, found, true);
+    arrayAppend(encounteredWorkarounds, InPlaceInit, found, true);
 }
 
 Containers::Array<std::pair<Containers::StringView, bool>> disableAllWorkarounds() {
     Containers::Array<std::pair<Containers::StringView, bool>> encounteredWorkarounds;
     for(const Containers::StringView i: KnownWorkarounds)
-        arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, i, true);
+        arrayAppend(encounteredWorkarounds, InPlaceInit, i, true);
     return encounteredWorkarounds;
 }
 
@@ -123,7 +123,7 @@ bool isDriverWorkaroundDisabled(Containers::Array<std::pair<Containers::StringVi
        the views in the KnownWorkarounds list. */
     for(const auto& i: encounteredWorkarounds)
         if(i.first.data() == found.data()) return i.second;
-    arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, found, false);
+    arrayAppend(encounteredWorkarounds, InPlaceInit, found, false);
     return false;
 }
 

src/Magnum/Vk/Implementation/spirvPatching.h

@@ -61,8 +61,8 @@ bool spirvPatchSwiftShaderConflictingMultiEntrypointLocations(Containers::ArrayV
     /* Get locations and storage classes for all entrypoint interfaces */
     Containers::ArrayView<ShaderTools::Implementation::SpirvEntrypointInterface> vertexInterface, fragmentInterface;
     Containers::ArrayTuple interfaceData{
-        {Containers::ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface},
-        {Containers::ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface}
+        {ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface},
+        {ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface}
     };
     spirvEntrypointInterface(data, *vertexEntryPoint, vertexInterface);
     spirvEntrypointInterface(data, *fragmentEntryPoint, fragmentInterface);

src/Magnum/Vk/Instance.cpp

@@ -189,7 +189,7 @@ InstanceCreateInfo& InstanceCreateInfo::addEnabledLayers(const Containers::Array
            don't get invalidated when the array gets reallocated. */
         const char* data;
         if(!(layer.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
-            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
+            data = arrayAppend(_state->ownedStrings, InPlaceInit,
                 Containers::AllocatedInit, layer).data();
         else data = layer.data();
 
@@ -223,7 +223,7 @@ InstanceCreateInfo& InstanceCreateInfo::addEnabledExtensions(const Containers::A
            don't get invalidated when the array gets reallocated. */
         const char* data;
         if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
-            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
+            data = arrayAppend(_state->ownedStrings, InPlaceInit,
                 Containers::AllocatedInit, extension).data();
         else data = extension.data();
 

src/Magnum/Vk/Mesh.cpp

@@ -91,10 +91,10 @@ Mesh::Mesh(MeshLayout&& layout): _layout{std::move(layout)} {
     if(const UnsignedInt count = _layout.vkPipelineVertexInputStateCreateInfo().vertexBindingDescriptionCount) {
         _state.emplace();
         _state->vertexBufferData = Containers::ArrayTuple{
-            {Containers::ValueInit, count, _state->vertexBuffers},
-            {Containers::ValueInit, count, _state->vertexBufferOffsets},
-            {Containers::ValueInit, count, _state->vertexBufferStrides},
-            {Containers::NoInit, count, _state->ownedVertexBuffers}
+            {ValueInit, count, _state->vertexBuffers},
+            {ValueInit, count, _state->vertexBufferOffsets},
+            {ValueInit, count, _state->vertexBufferStrides},
+            {NoInit, count, _state->ownedVertexBuffers}
         };
 
         /** @tod use DirectInit once ArrayTuple can do that */

src/Magnum/Vk/Pipeline.cpp

@@ -54,7 +54,7 @@ struct RasterizationPipelineCreateInfo::State {
     VkRect2D scissor;
 };
 
-RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet& shaderSet, const MeshLayout& meshLayout, const VkPipelineLayout pipelineLayout, const VkRenderPass renderPass, const UnsignedInt subpass, const UnsignedInt subpassColorAttachmentCount, Flags flags): _info{}, _viewportInfo{}, _rasterizationInfo{}, _multisampleInfo{}, _depthStencilInfo{}, _colorBlendInfo{}, _dynamicInfo{}, _state{Containers::InPlaceInit} {
+RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet& shaderSet, const MeshLayout& meshLayout, const VkPipelineLayout pipelineLayout, const VkRenderPass renderPass, const UnsignedInt subpass, const UnsignedInt subpassColorAttachmentCount, Flags flags): _info{}, _viewportInfo{}, _rasterizationInfo{}, _multisampleInfo{}, _depthStencilInfo{}, _colorBlendInfo{}, _dynamicInfo{}, _state{InPlaceInit} {
     _info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
     _info.flags = VkPipelineCreateFlags(flags);
     _info.stageCount = shaderSet.stages().size();
@@ -82,7 +82,7 @@ RasterizationPipelineCreateInfo::RasterizationPipelineCreateInfo(const ShaderSet
     _depthStencilInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
     _info.pDepthStencilState = &_depthStencilInfo;
 
-    _state->colorBlendAttachments = Containers::Array<VkPipelineColorBlendAttachmentState>{Containers::ValueInit, subpassColorAttachmentCount};
+    _state->colorBlendAttachments = Containers::Array<VkPipelineColorBlendAttachmentState>{ValueInit, subpassColorAttachmentCount};
     for(VkPipelineColorBlendAttachmentState& i: _state->colorBlendAttachments) {
         i.colorWriteMask = VK_COLOR_COMPONENT_R_BIT|
                            VK_COLOR_COMPONENT_G_BIT|
@@ -254,7 +254,7 @@ RasterizationPipelineCreateInfo& RasterizationPipelineCreateInfo::setDynamicStat
     std::size_t count = 0;
     for(std::size_t i = 0; i != DynamicRasterizationStates::Size; ++i)
         count += Math::popcount(states.data()[i]);
-    _state->dynamicStateList = Containers::Array<VkDynamicState>{Containers::NoInit, count};
+    _state->dynamicStateList = Containers::Array<VkDynamicState>{NoInit, count};
 
     std::size_t offset = 0;
     for(std::uint64_t i = 0; i != Containers::arraySize(DynamicRasterizationStateMapping); ++i)

src/Magnum/Vk/PipelineLayout.cpp

@@ -39,7 +39,7 @@ PipelineLayoutCreateInfo::PipelineLayoutCreateInfo(const Containers::ArrayView<c
     /* Make a copy of the descriptor set layout list */
     Containers::ArrayView<VkDescriptorSetLayout> descriptorSetLayoutsCopy;
     _data = Containers::ArrayTuple{
-        {Containers::NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy}
+        {NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy}
     };
     Utility::copy(descriptorSetLayouts, descriptorSetLayoutsCopy);
 

src/Magnum/Vk/Queue.cpp

@@ -73,7 +73,7 @@ void Queue::submit(const Containers::ArrayView<const Containers::Reference<const
         return;
     }
 
-    Containers::Array<VkSubmitInfo> vkInfos{Containers::NoInit, infos.size()};
+    Containers::Array<VkSubmitInfo> vkInfos{NoInit, infos.size()};
     for(std::size_t i = 0; i != infos.size(); ++i)
         vkInfos[i] = *infos[i];
 
@@ -140,7 +140,7 @@ SubmitInfo& SubmitInfo::operator=(SubmitInfo&& other) noexcept {
 SubmitInfo& SubmitInfo::setCommandBuffers(const Containers::ArrayView<const VkCommandBuffer> buffers) {
     if(!_state) _state.emplace();
 
-    _state->commandBuffers = Containers::Array<VkCommandBuffer>{Containers::NoInit, buffers.size()};
+    _state->commandBuffers = Containers::Array<VkCommandBuffer>{NoInit, buffers.size()};
     Utility::copy(buffers, _state->commandBuffers);
     _info.commandBufferCount = _state->commandBuffers.size();
     _info.pCommandBuffers = _state->commandBuffers;

src/Magnum/Vk/RenderPass.cpp

@@ -199,7 +199,7 @@ SubpassDescription::SubpassDescription(const VkSubpassDescription& description):
     nullptr,
     description.preserveAttachmentCount,
     description.pPreserveAttachments
-}, _state{Containers::InPlaceInit} {
+}, _state{InPlaceInit} {
     /* Convert all attachment references to the "version 2" format */
     setInputAttachmentsInternal<VkAttachmentReference>({description.pInputAttachments, description.inputAttachmentCount});
     setColorAttachmentsInternal<VkAttachmentReference>({description.pColorAttachments, description.colorAttachmentCount}, {description.pResolveAttachments, description.pResolveAttachments ? description.colorAttachmentCount : 0});
@@ -450,7 +450,7 @@ Containers::Array<VkSubpassDescription> SubpassDescription::vkSubpassDescription
        converted VkAttachmentReference instances it needs. Expect the default
        deleter is used so we don't need to wrap some other below. */
     const std::size_t extrasSize = vkSubpassDescriptionExtrasSize(_description);
-    Containers::Array<char> storage{Containers::NoInit, sizeof(VkSubpassDescription) + extrasSize};
+    Containers::Array<char> storage{NoInit, sizeof(VkSubpassDescription) + extrasSize};
     CORRADE_INTERNAL_ASSERT(!storage.deleter());
 
     /* Fill it with data and return, faking a size of 1 and with a custom
@@ -702,7 +702,7 @@ Containers::Array<VkRenderPassCreateInfo> RenderPassCreateInfo::vkRenderPassCrea
     /* Allocate an array to fit VkRenderPassCreateInfo together with all extras
        it needs. Expect the default deleter is used so we don't need to wrap
        some other below. */
-    Containers::Array<char> storage{Containers::NoInit, sizeof(VkRenderPassCreateInfo) + structuresSize + extrasSize};
+    Containers::Array<char> storage{NoInit, sizeof(VkRenderPassCreateInfo) + structuresSize + extrasSize};
     CORRADE_INTERNAL_ASSERT(!storage.deleter());
 
     /* Copy what can be copied for the output info struct. The pointers will be
@@ -889,7 +889,7 @@ RenderPassBeginInfo& RenderPassBeginInfo::clearDepthStencil(const UnsignedInt at
 RenderPassBeginInfo& RenderPassBeginInfo::clearInternal(const UnsignedInt attachment, const VkClearValue& value) {
     if(!_state) _state.emplace();
     if(_state->clearValues.size() <= attachment)
-        arrayResize(_state->clearValues, Containers::NoInit, attachment + 1);
+        arrayResize(_state->clearValues, NoInit, attachment + 1);
     _state->clearValues[attachment] = value;
     _info.clearValueCount = _state->clearValues.size();
     _info.pClearValues = _state->clearValues;

src/Magnum/Vk/Shader.cpp

@@ -137,7 +137,7 @@ VkResult Shader::createImplementationSwiftShaderMultiEntryPointPatching(Device&
        might not need to copy it, the owned code may also be read-only for
        whatever reason (memory-mapped location etc). Thus, to prevent issues,
        we go the safe route and copy always. */
-    Containers::Array<char> mutableCode{Containers::NoInit, info.codeSize};
+    Containers::Array<char> mutableCode{NoInit, info.codeSize};
     Utility::copy(Containers::arrayView(reinterpret_cast<const char*>(info.pCode), info.codeSize), mutableCode);
 
     /* If the code looks like SPIR-V, patch it. If not, supply the original and

src/Magnum/Vk/ShaderSet.cpp

@@ -82,7 +82,7 @@ ShaderSet& ShaderSet::addShader(const ShaderStage stage, const VkShaderModule sh
         if(!_state) _state.emplace();
         /* Ensure the data are never SSO'd and so when the array reallocates we
            don't need to rewire existing name pointers */
-        _stages[_stageCount].pName = arrayAppend(_state->entrypointNames, Containers::InPlaceInit, Containers::AllocatedInit, entrypoint).data();
+        _stages[_stageCount].pName = arrayAppend(_state->entrypointNames, InPlaceInit, Containers::AllocatedInit, entrypoint).data();
     }
 
     /* Specialization, also only if there are any to avoid allocating the state
@@ -98,8 +98,8 @@ ShaderSet& ShaderSet::addShader(const ShaderStage stage, const VkShaderModule sh
         /* The data is (currently) always four bytes, so we don't need to do
            any extra work to calculate the total data size over all
            specializations */
-        const Containers::ArrayView<char> newSpecializationData = arrayAppend(_state->specializationData, Containers::NoInit, specializations.size()*4);
-        const Containers::ArrayView<VkSpecializationMapEntry> newSpecializations = arrayAppend(_state->specializations, Containers::NoInit, specializations.size());
+        const Containers::ArrayView<char> newSpecializationData = arrayAppend(_state->specializationData, NoInit, specializations.size()*4);
+        const Containers::ArrayView<VkSpecializationMapEntry> newSpecializations = arrayAppend(_state->specializations, NoInit, specializations.size());
 
         /* Reroute the existing structures for possible reallocations */
         for(std::size_t i = 0; i != _stageCount; ++i) {

src/Magnum/Vk/Test/PipelineTest.cpp

@@ -306,11 +306,11 @@ void PipelineTest::rasterizationCreateInfoConstructMove() {
 
     MeshLayout meshLayout{MeshPrimitive::Triangles};
 
-    Containers::Pointer<RasterizationPipelineCreateInfo> a{Containers::InPlaceInit, shaderSet, meshLayout, VkPipelineLayout{}, VkRenderPass{}, 0u, 3u};
+    Containers::Pointer<RasterizationPipelineCreateInfo> a{InPlaceInit, shaderSet, meshLayout, VkPipelineLayout{}, VkRenderPass{}, 0u, 3u};
     (*a).setViewport(Range3D{})
         .setDynamicStates(DynamicRasterizationState::CullMode);
 
-    Containers::Pointer<RasterizationPipelineCreateInfo> b{Containers::InPlaceInit, std::move(*a)};
+    Containers::Pointer<RasterizationPipelineCreateInfo> b{InPlaceInit, std::move(*a)};
     CORRADE_COMPARE((**a).stageCount, 0);
     CORRADE_VERIFY(!(**a).pStages);
     CORRADE_VERIFY(!(**a).pVertexInputState);
@@ -344,7 +344,7 @@ void PipelineTest::rasterizationCreateInfoConstructMove() {
     CORRADE_VERIFY((**b).pDynamicState);
     CORRADE_COMPARE((**b).pDynamicState->sType, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
 
-    Containers::Pointer<RasterizationPipelineCreateInfo> c{Containers::InPlaceInit, VkGraphicsPipelineCreateInfo{}};
+    Containers::Pointer<RasterizationPipelineCreateInfo> c{InPlaceInit, VkGraphicsPipelineCreateInfo{}};
     *c = std::move(*b);
     CORRADE_COMPARE((**b).stageCount, 0);
     CORRADE_VERIFY(!(**b).pStages);

src/Magnum/Vk/Test/RenderPassTest.cpp

@@ -242,7 +242,7 @@ template<class> struct Traits;
         static const char* name() { return #type "2"; }                     \
         /* So we have the same interface in both cases */                   \
         static Containers::Array<Vk ## type ## 2> convert(const type& instance) { \
-            return {Containers::InPlaceInit, {*instance}};                  \
+            return {InPlaceInit, {*instance}};                              \
         }                                                                   \
     };
 _c(AttachmentDescription)

src/MagnumPlugins/AnyShaderConverter/AnyConverter.cpp

@@ -49,7 +49,7 @@ struct AnyConverter::State {
 
 AnyConverter::AnyConverter(PluginManager::Manager<AbstractConverter>& manager): AbstractConverter{manager} {}
 
-AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{Containers::InPlaceInit} {}
+AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{InPlaceInit} {}
 
 AnyConverter::~AnyConverter() = default;
 

src/MagnumPlugins/MagnumFontConverter/Test/MagnumFontConverterTest.cpp

@@ -125,7 +125,7 @@ void MagnumFontConverterTest::exportFont() {
         GlyphCacheFeatures doFeatures() const override { return GlyphCacheFeature::ImageDownload; }
         void doSetImage(const Vector2i&, const ImageView2D&) override {}
         Image2D doImage() override {
-            return Image2D{PixelFormat::R8Unorm, Vector2i{256}, Containers::Array<char>{Containers::ValueInit, 256*256}};
+            return Image2D{PixelFormat::R8Unorm, Vector2i{256}, Containers::Array<char>{ValueInit, 256*256}};
         }
     } cache;
     cache.insert(font.glyphId(U'W'), {25, 34}, {{0, 8}, {16, 128}});

src/MagnumPlugins/ObjImporter/ObjImporter.cpp

@@ -429,7 +429,7 @@ Containers::Optional<MeshData> ObjImporter::doMesh(UnsignedInt id, UnsignedInt)
 
     /* Merge index arrays. If any of the attributes was not there, the whole
        index array has zeros, not affecting the uniqueness in any way. */
-    Containers::Array<char> indexData{Containers::NoInit, indices.size()*sizeof(UnsignedInt)};
+    Containers::Array<char> indexData{NoInit, indices.size()*sizeof(UnsignedInt)};
     const auto indexDataI = Containers::arrayCast<UnsignedInt>(indexData);
     const std::size_t vertexCount = MeshTools::removeDuplicatesInPlaceInto(
         Containers::arrayCast<2, char>(arrayView(indices)), indexDataI);
@@ -446,7 +446,7 @@ Containers::Optional<MeshData> ObjImporter::doMesh(UnsignedInt id, UnsignedInt)
         stride += sizeof(Vector2);
     }
     Containers::Array<MeshAttributeData> attributeData{attributeCount};
-    Containers::Array<char> vertexData{Containers::NoInit, vertexCount*stride};
+    Containers::Array<char> vertexData{NoInit, vertexCount*stride};
 
     /* Duplicate the vertices into the output */
     const auto indicesPerAttribute = Containers::arrayCast<2, const UnsignedInt>(stridedArrayView(indices)).transposed<0, 1>();

src/MagnumPlugins/TgaImageConverter/TgaImageConverter.cpp

@@ -48,7 +48,7 @@ ImageConverterFeatures TgaImageConverter::doFeatures() const { return ImageConve
 Containers::Array<char> TgaImageConverter::doConvertToData(const ImageView2D& image) {
     /* Initialize data buffer */
     const auto pixelSize = UnsignedByte(image.pixelSize());
-    Containers::Array<char> data{Containers::ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()};
+    Containers::Array<char> data{ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()};
 
     /* Fill header */
     auto header = reinterpret_cast<Implementation::TgaHeader*>(data.begin());