mosra / magnum
Showing 48 of 85 files from the diff.
Other files ignored by Codecov
src/Magnum/Tags.h has changed.

@@ -796,7 +796,7 @@
Loading
796 796
    /* Driver workarounds get merged. Not using disableDriverWorkaround() here
797 797
       since the Configuration already contains the internal string views. */
798 798
    for(const Containers::StringView workaround: configuration.disabledWorkarounds())
799 -
        arrayAppend(_driverWorkarounds, Containers::InPlaceInit, workaround, true);
799 +
        arrayAppend(_driverWorkarounds, InPlaceInit, workaround, true);
800 800
801 801
    /* Extensions get merged also. Here we had the chance to force users to
802 802
       give us the predefined extension types so no need to search for their
@@ -1208,7 +1208,7 @@
Loading
1208 1208
    _flags = other._flags;
1209 1209
    arrayResize(_disabledWorkarounds, 0);
1210 1210
    /** @todo arrayClear(), ffs */
1211 -
    arrayResize(_disabledExtensions, Containers::NoInit, 0);
1211 +
    arrayResize(_disabledExtensions, NoInit, 0);
1212 1212
    addDisabledWorkarounds(other._disabledWorkarounds);
1213 1213
    addDisabledExtensions(other._disabledExtensions);
1214 1214
    return *this;

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

@@ -189,7 +189,7 @@
Loading
189 189
           don't get invalidated when the array gets reallocated. */
190 190
        const char* data;
191 191
        if(!(layer.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
192 -
            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
192 +
            data = arrayAppend(_state->ownedStrings, InPlaceInit,
193 193
                Containers::AllocatedInit, layer).data();
194 194
        else data = layer.data();
195 195
@@ -223,7 +223,7 @@
Loading
223 223
           don't get invalidated when the array gets reallocated. */
224 224
        const char* data;
225 225
        if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
226 -
            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
226 +
            data = arrayAppend(_state->ownedStrings, InPlaceInit,
227 227
                Containers::AllocatedInit, extension).data();
228 228
        else data = extension.data();
229 229

@@ -39,7 +39,7 @@
Loading
39 39
    /* Make a copy of the descriptor set layout list */
40 40
    Containers::ArrayView<VkDescriptorSetLayout> descriptorSetLayoutsCopy;
41 41
    _data = Containers::ArrayTuple{
42 -
        {Containers::NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy}
42 +
        {NoInit, descriptorSetLayouts.size(), descriptorSetLayoutsCopy}
43 43
    };
44 44
    Utility::copy(descriptorSetLayouts, descriptorSetLayoutsCopy);
45 45

@@ -106,7 +106,7 @@
Loading
106 106
        _duration = track.duration();
107 107
    else
108 108
        _duration = Math::join(track.duration(), _duration);
109 -
    arrayAppend(_tracks, Containers::InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u);
109 +
    arrayAppend(_tracks, InPlaceInit, track, advancer, destination, userCallback, userCallbackData, 0u);
110 110
    return *this;
111 111
}
112 112
@@ -252,7 +252,7 @@
Loading
252 252
        }
253 253
    }
254 254
255 -
    return {Containers::InPlaceInit, playIteration, key};
255 +
    return {InPlaceInit, playIteration, key};
256 256
}
257 257
258 258
}

@@ -496,7 +496,7 @@
Loading
496 496
        return;
497 497
    }
498 498
499 -
    arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, true);
499 +
    arrayAppend(_driverWorkarounds, InPlaceInit, found, true);
500 500
}
501 501
502 502
bool Context::isDriverWorkaroundDisabled(const Containers::StringView workaround) {
@@ -512,7 +512,7 @@
Loading
512 512
       the views in the KnownWorkarounds list. */
513 513
    for(const auto& i: _driverWorkarounds)
514 514
        if(i.first.data() == found.data()) return i.second;
515 -
    arrayAppend(_driverWorkarounds, Containers::InPlaceInit, found, false);
515 +
    arrayAppend(_driverWorkarounds, InPlaceInit, found, false);
516 516
    return false;
517 517
}
518 518
@@ -633,7 +633,7 @@
Loading
633 633
            continue;
634 634
        }
635 635
636 -
        arrayAppend(_disabledWorkarounds, Containers::InPlaceInit, found);
636 +
        arrayAppend(_disabledWorkarounds, InPlaceInit, found);
637 637
    }
638 638
639 639
    return *this;

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

@@ -48,7 +48,7 @@
Loading
48 48
Containers::Array<char> TgaImageConverter::doConvertToData(const ImageView2D& image) {
49 49
    /* Initialize data buffer */
50 50
    const auto pixelSize = UnsignedByte(image.pixelSize());
51 -
    Containers::Array<char> data{Containers::ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()};
51 +
    Containers::Array<char> data{ValueInit, sizeof(Implementation::TgaHeader) + pixelSize*image.size().product()};
52 52
53 53
    /* Fill header */
54 54
    auto header = reinterpret_cast<Implementation::TgaHeader*>(data.begin());

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

@@ -76,7 +76,7 @@
Loading
76 76
    }
77 77
78 78
    /* Set up the layout */
79 -
    Containers::Array<char> vertexData{Containers::NoInit, 4*stride};
79 +
    Containers::Array<char> vertexData{NoInit, 4*stride};
80 80
    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
81 81
    std::size_t attributeIndex = 0;
82 82
    std::size_t attributeOffset = 0;

@@ -100,13 +100,13 @@
Loading
100 100
        return;
101 101
    }
102 102
103 -
    arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, found, true);
103 +
    arrayAppend(encounteredWorkarounds, InPlaceInit, found, true);
104 104
}
105 105
106 106
Containers::Array<std::pair<Containers::StringView, bool>> disableAllWorkarounds() {
107 107
    Containers::Array<std::pair<Containers::StringView, bool>> encounteredWorkarounds;
108 108
    for(const Containers::StringView i: KnownWorkarounds)
109 -
        arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, i, true);
109 +
        arrayAppend(encounteredWorkarounds, InPlaceInit, i, true);
110 110
    return encounteredWorkarounds;
111 111
}
112 112
@@ -123,7 +123,7 @@
Loading
123 123
       the views in the KnownWorkarounds list. */
124 124
    for(const auto& i: encounteredWorkarounds)
125 125
        if(i.first.data() == found.data()) return i.second;
126 -
    arrayAppend(encounteredWorkarounds, Containers::InPlaceInit, found, false);
126 +
    arrayAppend(encounteredWorkarounds, InPlaceInit, found, false);
127 127
    return false;
128 128
}
129 129

@@ -181,7 +181,7 @@
Loading
181 181
182 182
    /* If we don't have all frames yet, enlarge the array */
183 183
    if(++_measuredFrameCount <= _maxFrameCount)
184 -
        arrayAppend(_data, Containers::NoInit, _measurements.size());
184 +
        arrayAppend(_data, NoInit, _measurements.size());
185 185
186 186
    /* Wrap up measurements for this frame  */
187 187
    for(std::size_t i = 0; i != _measurements.size(); ++i) {
@@ -448,7 +448,7 @@
Loading
448 448
    #endif
449 449
};
450 450
451 -
GLFrameProfiler::GLFrameProfiler(): _state{Containers::InPlaceInit} {}
451 +
GLFrameProfiler::GLFrameProfiler(): _state{InPlaceInit} {}
452 452
453 453
GLFrameProfiler::GLFrameProfiler(const Values values, const UnsignedInt maxFrameCount): GLFrameProfiler{}
454 454
{
@@ -468,7 +468,7 @@
Loading
468 468
        /* Fucking hell, STL. When I first saw std::chrono back in 2010 I
469 469
           should have flipped the table and learn carpentry instead. BUT NO,
470 470
           I'm still suffering this abomination a decade later! */
471 -
        arrayAppend(measurements, Containers::InPlaceInit,
471 +
        arrayAppend(measurements, InPlaceInit,
472 472
            "Frame time", Units::Nanoseconds, UnsignedInt(Containers::arraySize(_state->frameTimeStartFrame)),
473 473
            [](void* state, UnsignedInt current) {
474 474
                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 @@
Loading
482 482
        _state->frameTimeIndex = index++;
483 483
    }
484 484
    if(values & Value::CpuDuration) {
485 -
        arrayAppend(measurements, Containers::InPlaceInit,
485 +
        arrayAppend(measurements, InPlaceInit,
486 486
            "CPU duration", Units::Nanoseconds,
487 487
            [](void* state) {
488 488
                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 @@
Loading
496 496
    if(values & Value::GpuDuration) {
497 497
        for(GL::TimeQuery& q: _state->timeQueries)
498 498
            q = GL::TimeQuery{GL::TimeQuery::Target::TimeElapsed};
499 -
        arrayAppend(measurements, Containers::InPlaceInit,
499 +
        arrayAppend(measurements, InPlaceInit,
500 500
            "GPU duration", Units::Nanoseconds,
501 501
            UnsignedInt(Containers::arraySize(_state->timeQueries)),
502 502
            [](void* state, UnsignedInt current) {
@@ -516,7 +516,7 @@
Loading
516 516
            q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VerticesSubmitted};
517 517
        for(GL::PipelineStatisticsQuery& q: _state->vertexShaderInvocationsQueries)
518 518
            q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VertexShaderInvocations};
519 -
        arrayAppend(measurements, Containers::InPlaceInit,
519 +
        arrayAppend(measurements, InPlaceInit,
520 520
            "Vertex fetch ratio", Units::RatioThousandths,
521 521
            UnsignedInt(Containers::arraySize(_state->verticesSubmittedQueries)),
522 522
            [](void* state, UnsignedInt current) {
@@ -541,7 +541,7 @@
Loading
541 541
            q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingInputPrimitives};
542 542
        for(GL::PipelineStatisticsQuery& q: _state->clippingOutputPrimitivesQueries)
543 543
            q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingOutputPrimitives};
544 -
        arrayAppend(measurements, Containers::InPlaceInit,
544 +
        arrayAppend(measurements, InPlaceInit,
545 545
            "Primitives clipped", Units::PercentageThousandths,
546 546
            UnsignedInt(Containers::arraySize(_state->clippingInputPrimitivesQueries)),
547 547
            [](void* state, UnsignedInt current) {

@@ -132,7 +132,7 @@
Loading
132 132
    }
133 133
134 134
    /* Set up the layout */
135 -
    Containers::Array<char> vertexData{Containers::NoInit, (segments + 2)*stride};
135 +
    Containers::Array<char> vertexData{NoInit, (segments + 2)*stride};
136 136
    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
137 137
    std::size_t attributeIndex = 0;
138 138
    std::size_t attributeOffset = 0;

@@ -96,8 +96,8 @@
Loading
96 96
        Vector3 normal;
97 97
    };
98 98
    Containers::Array<char> vertexData;
99 -
    Containers::arrayResize<Trade::ArrayAllocator>(vertexData,
100 -
        Containers::NoInit, sizeof(Vertex)*vertexCount);
99 +
    Containers::arrayResize<Trade::ArrayAllocator>(vertexData, NoInit,
100 +
        sizeof(Vertex)*vertexCount);
101 101
102 102
    /* Build up the subdivided positions */
103 103
    {

@@ -91,10 +91,10 @@
Loading
91 91
    if(const UnsignedInt count = _layout.vkPipelineVertexInputStateCreateInfo().vertexBindingDescriptionCount) {
92 92
        _state.emplace();
93 93
        _state->vertexBufferData = Containers::ArrayTuple{
94 -
            {Containers::ValueInit, count, _state->vertexBuffers},
95 -
            {Containers::ValueInit, count, _state->vertexBufferOffsets},
96 -
            {Containers::ValueInit, count, _state->vertexBufferStrides},
97 -
            {Containers::NoInit, count, _state->ownedVertexBuffers}
94 +
            {ValueInit, count, _state->vertexBuffers},
95 +
            {ValueInit, count, _state->vertexBufferOffsets},
96 +
            {ValueInit, count, _state->vertexBufferStrides},
97 +
            {NoInit, count, _state->ownedVertexBuffers}
98 98
        };
99 99
100 100
        /** @tod use DirectInit once ArrayTuple can do that */

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

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

@@ -73,7 +73,7 @@
Loading
73 73
        return;
74 74
    }
75 75
76 -
    Containers::Array<VkSubmitInfo> vkInfos{Containers::NoInit, infos.size()};
76 +
    Containers::Array<VkSubmitInfo> vkInfos{NoInit, infos.size()};
77 77
    for(std::size_t i = 0; i != infos.size(); ++i)
78 78
        vkInfos[i] = *infos[i];
79 79
@@ -140,7 +140,7 @@
Loading
140 140
SubmitInfo& SubmitInfo::setCommandBuffers(const Containers::ArrayView<const VkCommandBuffer> buffers) {
141 141
    if(!_state) _state.emplace();
142 142
143 -
    _state->commandBuffers = Containers::Array<VkCommandBuffer>{Containers::NoInit, buffers.size()};
143 +
    _state->commandBuffers = Containers::Array<VkCommandBuffer>{NoInit, buffers.size()};
144 144
    Utility::copy(buffers, _state->commandBuffers);
145 145
    _info.commandBufferCount = _state->commandBuffers.size();
146 146
    _info.pCommandBuffers = _state->commandBuffers;

@@ -51,7 +51,7 @@
Loading
51 51
    /* Size in the last dimension is byte size of the pixel, the remaining
52 52
       dimensions are reverted (first images, then rows, then pixels, last
53 53
       pixel bytes) */
54 -
    Containers::StridedDimensions<dimensions + 1, std::size_t> size{Containers::NoInit};
54 +
    Containers::StridedDimensions<dimensions + 1, std::size_t> size{NoInit};
55 55
    size[dimensions] = image.pixelSize();
56 56
    for(UnsignedInt i = dimensions; i != 0; --i)
57 57
        size[i - 1] = image.size()[dimensions - i];
@@ -61,7 +61,7 @@
Loading
61 61
       (first image size, then row size, then pixel size, last 1). The
62 62
       data properties include pixel size in row size, so we have to take it
63 63
       out from the cumulative product. */
64 -
    Containers::StridedDimensions<dimensions + 1, std::ptrdiff_t> stride{Containers::NoInit};
64 +
    Containers::StridedDimensions<dimensions + 1, std::ptrdiff_t> stride{NoInit};
65 65
    stride[dimensions] = 1;
66 66
    stride[dimensions - 1] = 1;
67 67
    for(UnsignedInt i = dimensions - 1; i != 0; --i)

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

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

@@ -260,11 +260,11 @@
Loading
260 260
        setShininess(80.0f);
261 261
        if(flags & Flag::NormalTexture)
262 262
            setNormalTextureScale(1.0f);
263 -
        setLightPositions(Containers::Array<Vector4>{Containers::DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}});
264 -
        Containers::Array<Magnum::Color3> colors{Containers::DirectInit, lightCount, Magnum::Color3{1.0f}};
263 +
        setLightPositions(Containers::Array<Vector4>{DirectInit, lightCount, Vector4{0.0f, 0.0f, 1.0f, 0.0f}});
264 +
        Containers::Array<Magnum::Color3> colors{DirectInit, lightCount, Magnum::Color3{1.0f}};
265 265
        setLightColors(colors);
266 266
        setLightSpecularColors(colors);
267 -
        setLightRanges(Containers::Array<Float>{Containers::DirectInit, lightCount, Constants::inf()});
267 +
        setLightRanges(Containers::Array<Float>{DirectInit, lightCount, Constants::inf()});
268 268
        /* Light position is zero by default */
269 269
        setNormalMatrix(Matrix3x3{Math::IdentityInit});
270 270
    }
@@ -390,7 +390,7 @@
Loading
390 390
391 391
#ifdef MAGNUM_BUILD_DEPRECATED
392 392
Phong& Phong::setLightPositions(const Containers::ArrayView<const Vector3> positions) {
393 -
    Containers::Array<Vector4> fourComponent{Containers::NoInit, positions.size()};
393 +
    Containers::Array<Vector4> fourComponent{NoInit, positions.size()};
394 394
    for(std::size_t i = 0; i != positions.size(); ++i)
395 395
        fourComponent[i] = Vector4{positions[i], 0.0f};
396 396
    setLightPositions(fourComponent);
@@ -431,7 +431,7 @@
Loading
431 431
432 432
#ifdef MAGNUM_BUILD_DEPRECATED
433 433
Phong& Phong::setLightColors(const Containers::ArrayView<const Magnum::Color4> colors) {
434 -
    Containers::Array<Magnum::Color3> threeComponent{Containers::NoInit, colors.size()};
434 +
    Containers::Array<Magnum::Color3> threeComponent{NoInit, colors.size()};
435 435
    for(std::size_t i = 0; i != colors.size(); ++i)
436 436
        threeComponent[i] = colors[i].rgb();
437 437
    setLightColors(threeComponent);

@@ -59,8 +59,7 @@
Loading
59 59
60 60
    /* Allocate resulting attribute and vertex data and duplicate the
61 61
       attributes there according to the combined index buffer */
62 -
    Containers::Array<char> vertexData{Containers::NoInit,
63 -
        vertexStride*vertexCount};
62 +
    Containers::Array<char> vertexData{NoInit, vertexStride*vertexCount};
64 63
    Containers::Array<Trade::MeshAttributeData> attributeData{attributeCount};
65 64
    {
66 65
        std::size_t indexOffset = 0;
@@ -133,8 +132,7 @@
Loading
133 132
        reading 32-bit values from odd addresses on some platforms) */
134 133
135 134
    /* Create a combined index array */
136 -
    Containers::Array<char> combinedIndices{Containers::NoInit,
137 -
        indexCount*indexStride};
135 +
    Containers::Array<char> combinedIndices{NoInit, indexCount*indexStride};
138 136
    {
139 137
        std::size_t indexOffset = 0;
140 138
        for(const Trade::MeshData& mesh: data) {
@@ -177,8 +175,7 @@
Loading
177 175
    const UnsignedInt faceIndexSize = faceAttributes.isIndexed() ?
178 176
        meshIndexTypeSize(faceAttributes.indexType()) : 4;
179 177
    const UnsignedInt indexStride = meshIndexSize + faceIndexSize;
180 -
    Containers::Array<char> combinedIndices{Containers::NoInit,
181 -
        meshIndexCount*indexStride};
178 +
    Containers::Array<char> combinedIndices{NoInit, meshIndexCount*indexStride};
182 179
    Utility::copy(mesh.indices(),
183 180
        Containers::StridedArrayView2D<char>{combinedIndices, {meshIndexCount, meshIndexSize}, {std::ptrdiff_t(indexStride), 1}});
184 181

@@ -98,7 +98,7 @@
Loading
98 98
}
99 99
100 100
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data) {
101 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
101 +
    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
102 102
    const std::size_t size = removeDuplicatesInto(data, indices);
103 103
    return {std::move(indices), size};
104 104
}
@@ -156,7 +156,7 @@
Loading
156 156
}
157 157
158 158
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data) {
159 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
159 +
    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
160 160
    const std::size_t size = removeDuplicatesInPlaceInto(data, indices);
161 161
    return {std::move(indices), size};
162 162
}
@@ -223,7 +223,7 @@
Loading
223 223
       to be robust. */
224 224
    const std::size_t vectorSize = data.size()[1];
225 225
    T range = T(0.0);
226 -
    Containers::Array<T> offsets{Containers::NoInit, vectorSize};
226 +
    Containers::Array<T> offsets{NoInit, vectorSize};
227 227
    {
228 228
        /** @todo this isn't really cache-efficient, do differently */
229 229
        std::size_t i = 0;
@@ -249,8 +249,8 @@
Loading
249 249
250 250
    /* Index array that'll be filled in each pass and then used for remapping
251 251
       the `indices`; discretized storage for all map keys. */
252 -
    Containers::Array<UnsignedInt> remapping{Containers::NoInit, dataSize};
253 -
    Containers::Array<std::size_t> discretized{Containers::NoInit, dataSize*vectorSize};
252 +
    Containers::Array<UnsignedInt> remapping{NoInit, dataSize};
253 +
    Containers::Array<std::size_t> discretized{NoInit, dataSize*vectorSize};
254 254
255 255
    /* First go with original coordinates, then move them by epsilon/2 in each
256 256
       dimension. */
@@ -349,7 +349,7 @@
Loading
349 349
}
350 350
351 351
template<class T> std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlaceImplementation(const Containers::StridedArrayView2D<T>& data, const T epsilon) {
352 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, data.size()[0]};
352 +
    Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
353 353
    const std::size_t size = removeDuplicatesFuzzyInPlaceIntoImplementation(data, indices, epsilon);
354 354
    return {std::move(indices), size};
355 355
}
@@ -425,7 +425,7 @@
Loading
425 425
        indexData = ownedInterleaved.releaseIndexData();
426 426
        indexType = ownedInterleaved.indexType();
427 427
    } else {
428 -
        indexData = Containers::Array<char>{Containers::NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)};
428 +
        indexData = Containers::Array<char>{NoInit, ownedInterleaved.vertexCount()*sizeof(UnsignedInt)};
429 429
        uniqueVertexCount = removeDuplicatesInPlaceInto(vertexData, Containers::arrayCast<UnsignedInt>(indexData));
430 430
        indexType = MeshIndexType::UnsignedInt;
431 431
    }
@@ -435,7 +435,7 @@
Loading
435 435
        or interleave() above, arrayResize() wouldn't release the excessive
436 436
        memory in any way. This is basically equivalent to STL's
437 437
        shrink_to_fit(), which also copies */
438 -
    Containers::Array<char> uniqueVertexData{Containers::NoInit, uniqueVertexCount*vertexData.size()[1]};
438 +
    Containers::Array<char> uniqueVertexData{NoInit, uniqueVertexCount*vertexData.size()[1]};
439 439
    Utility::copy(vertexData.prefix(uniqueVertexCount),
440 440
        Containers::StridedArrayView2D<char>{uniqueVertexData, {uniqueVertexCount, vertexData.size()[1]}});
441 441

@@ -53,7 +53,7 @@
Loading
53 53
}
54 54
55 55
Containers::Array<Vector3> generateFlatNormals(const Containers::StridedArrayView1D<const Vector3>& positions) {
56 -
    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
56 +
    Containers::Array<Vector3> out{NoInit, positions.size()};
57 57
    generateFlatNormalsInto(positions, Containers::arrayView(out));
58 58
    return out;
59 59
}
@@ -120,7 +120,7 @@
Loading
120 120
    /* Turn that into a running offset array:
121 121
       triangleOffset[i + 1] - triangleOffset[i] is triangle count for vertex i
122 122
       triangleOffset[i] is offset into an triangle ID array for vertex i */
123 -
    Containers::Array<UnsignedInt> triangleOffset{Containers::NoInit, positions.size() + 1};
123 +
    Containers::Array<UnsignedInt> triangleOffset{NoInit, positions.size() + 1};
124 124
    triangleOffset[0] = 0;
125 125
    for(std::size_t i = 0; i != triangleCount.size(); ++i)
126 126
        triangleOffset[i + 1] = triangleOffset[i] + triangleCount[i];
@@ -130,7 +130,7 @@
Loading
130 130
    /* Gather triangle IDs for every vertex. For vertex i,
131 131
       triangleIds[triangleOffset[i]] until triangleIds[triangleOffset[i + 1]]
132 132
       contains IDs of triangles that contain it. */
133 -
    Containers::Array<T> triangleIds{Containers::NoInit, indices.size()};
133 +
    Containers::Array<T> triangleIds{NoInit, indices.size()};
134 134
    for(std::size_t i = 0; i != indices.size(); ++i) {
135 135
        const T triangleId = i/3;
136 136
        const T vertexId = indices[i];
@@ -251,7 +251,7 @@
Loading
251 251
namespace {
252 252
253 253
template<class T> inline Containers::Array<Vector3> generateSmoothNormalsImplementation(const Containers::StridedArrayView1D<const T>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) {
254 -
    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
254 +
    Containers::Array<Vector3> out{NoInit, positions.size()};
255 255
    generateSmoothNormalsInto(indices, positions, out);
256 256
    return out;
257 257
}
@@ -272,7 +272,7 @@
Loading
272 272
}
273 273
274 274
Containers::Array<Vector3> generateSmoothNormals(const Containers::StridedArrayView2D<const char>& indices, const Containers::StridedArrayView1D<const Vector3>& positions) {
275 -
    Containers::Array<Vector3> out{Containers::NoInit, positions.size()};
275 +
    Containers::Array<Vector3> out{NoInit, positions.size()};
276 276
    generateSmoothNormalsInto(indices, positions, out);
277 277
    return out;
278 278
}

@@ -127,7 +127,7 @@
Loading
127 127
    if(data.vertexDataFlags() & Trade::DataFlag::Owned)
128 128
        vertexData = data.releaseVertexData();
129 129
    else {
130 -
        vertexData = Containers::Array<char>{Containers::NoInit, data.vertexData().size()};
130 +
        vertexData = Containers::Array<char>{NoInit, data.vertexData().size()};
131 131
        Utility::copy(data.vertexData(), vertexData);
132 132
    }
133 133

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

@@ -46,7 +46,7 @@
Loading
46 46
DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const UnsignedInt binding, const DescriptorType descriptorType, const Containers::ArrayView<const VkSampler> immutableSamplers, const ShaderStages stages, Flags flags): _binding{}, _flags{VkDescriptorBindingFlags(flags)} {
47 47
    Containers::ArrayView<VkSampler> immutableSamplersCopy;
48 48
    _data = Containers::ArrayTuple{
49 -
        {Containers::NoInit, immutableSamplers.size(), immutableSamplersCopy}
49 +
        {NoInit, immutableSamplers.size(), immutableSamplersCopy}
50 50
    };
51 51
    Utility::copy(immutableSamplers, immutableSamplersCopy);
52 52
@@ -109,10 +109,10 @@
Loading
109 109
    Containers::ArrayView<VkDescriptorSetLayoutBindingFlagsCreateInfo> bindingsCreateInfoView;
110 110
    Containers::ArrayView<VkSampler> immutableSamplersCopy;
111 111
    _data = Containers::ArrayTuple{
112 -
        {Containers::NoInit, bindings.size(), bindingsCopy},
113 -
        {Containers::NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy},
114 -
        {Containers::ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView},
115 -
        {Containers::NoInit, immutableSamplerCount, immutableSamplersCopy}
112 +
        {NoInit, bindings.size(), bindingsCopy},
113 +
        {NoInit, hasBindingFlags ? bindings.size() : 0, bindingFlagsCopy},
114 +
        {ValueInit, hasBindingFlags ? 1u : 0u, bindingsCreateInfoView},
115 +
        {NoInit, immutableSamplerCount, immutableSamplersCopy}
116 116
    };
117 117
118 118
    /* Copy the binding and then for each manually copy and reroute the

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

@@ -54,7 +54,7 @@
Loading
54 54
    VkRect2D scissor;
55 55
};
56 56
57 -
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} {
57 +
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} {
58 58
    _info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
59 59
    _info.flags = VkPipelineCreateFlags(flags);
60 60
    _info.stageCount = shaderSet.stages().size();
@@ -82,7 +82,7 @@
Loading
82 82
    _depthStencilInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
83 83
    _info.pDepthStencilState = &_depthStencilInfo;
84 84
85 -
    _state->colorBlendAttachments = Containers::Array<VkPipelineColorBlendAttachmentState>{Containers::ValueInit, subpassColorAttachmentCount};
85 +
    _state->colorBlendAttachments = Containers::Array<VkPipelineColorBlendAttachmentState>{ValueInit, subpassColorAttachmentCount};
86 86
    for(VkPipelineColorBlendAttachmentState& i: _state->colorBlendAttachments) {
87 87
        i.colorWriteMask = VK_COLOR_COMPONENT_R_BIT|
88 88
                           VK_COLOR_COMPONENT_G_BIT|
@@ -254,7 +254,7 @@
Loading
254 254
    std::size_t count = 0;
255 255
    for(std::size_t i = 0; i != DynamicRasterizationStates::Size; ++i)
256 256
        count += Math::popcount(states.data()[i]);
257 -
    _state->dynamicStateList = Containers::Array<VkDynamicState>{Containers::NoInit, count};
257 +
    _state->dynamicStateList = Containers::Array<VkDynamicState>{NoInit, count};
258 258
259 259
    std::size_t offset = 0;
260 260
    for(std::uint64_t i = 0; i != Containers::arraySize(DynamicRasterizationStateMapping); ++i)

@@ -120,7 +120,7 @@
Loading
120 120
    DeviceProperties properties{NoCreate};
121 121
};
122 122
123 -
DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{Containers::InPlaceInit} {
123 +
DeviceCreateInfo::DeviceCreateInfo(DeviceProperties& deviceProperties, const ExtensionProperties* extensionProperties, const Flags flags): _physicalDevice{deviceProperties}, _info{}, _state{InPlaceInit} {
124 124
    Utility::Arguments args = Implementation::arguments();
125 125
    args.parse(deviceProperties._instance->state().argc, deviceProperties._instance->state().argv);
126 126
@@ -307,7 +307,7 @@
Loading
307 307
           don't get invalidated when the array gets reallocated. */
308 308
        const char* data;
309 309
        if(!(extension.flags() >= (Containers::StringViewFlag::NullTerminated|Containers::StringViewFlag::Global)))
310 -
            data = arrayAppend(_state->ownedStrings, Containers::InPlaceInit,
310 +
            data = arrayAppend(_state->ownedStrings, InPlaceInit,
311 311
                Containers::AllocatedInit, extension).data();
312 312
        else data = extension.data();
313 313

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

@@ -67,7 +67,7 @@
Loading
67 67
    /* Otherwise copy them, if the mesh is indexed. If not, the
68 68
       default-constructed instances are fine. */
69 69
    } else if(data.isIndexed()) {
70 -
        indexData = Containers::Array<char>{Containers::NoInit, data.indexData().size()};
70 +
        indexData = Containers::Array<char>{NoInit, data.indexData().size()};
71 71
        indices = Trade::MeshIndexData{data.indexType(), indexData.slice(data.indexOffset(), data.indexOffset() + data.indexCount()*meshIndexTypeSize(data.indexType()))};
72 72
        Utility::copy(data.indexData(), indexData);
73 73
    }
@@ -83,7 +83,7 @@
Loading
83 83
84 84
    /* Otherwise copy them */
85 85
    } else {
86 -
        vertexData = Containers::Array<char>{Containers::NoInit, originalVertexData.size()};
86 +
        vertexData = Containers::Array<char>{NoInit, originalVertexData.size()};
87 87
        Utility::copy(originalVertexData, vertexData);
88 88
    }
89 89

@@ -467,7 +467,7 @@
Loading
467 467
}
468 468
469 469
Containers::Array<char> AbstractConverter::linkDataToDataUsingInputFileCallbacks(const char* const prefix, const Containers::ArrayView<const std::pair<Stage, Containers::StringView>> filenames) {
470 -
    Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, filenames.size()};
470 +
    Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, filenames.size()};
471 471
472 472
    /* First load all files. Remember how many of these succeeded so we can
473 473
       close them again after */
@@ -573,7 +573,7 @@
Loading
573 573
574 574
        /** @todo merge the allocations once we have an ArrayTuple (actually,
575 575
            ideally it would merge also the nested allocations, how?) */
576 -
        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, from.size()};
576 +
        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, from.size()};
577 577
        for(std::size_t i = 0; i != from.size(); ++i)  {
578 578
            data[i].first = from[i].first;
579 579
            data[i].second = fileData[i];
@@ -652,7 +652,7 @@
Loading
652 652
        }
653 653
654 654
        /** @todo merge the allocations once we have an ArrayTuple */
655 -
        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{Containers::NoInit, filenames.size()};
655 +
        Containers::Array<std::pair<Stage, Containers::ArrayView<const char>>> data{NoInit, filenames.size()};
656 656
        for(std::size_t i = 0; i != filenames.size(); ++i)  {
657 657
            data[i].first = filenames[i].first;
658 658
            data[i].second = fileData[i];

@@ -49,7 +49,7 @@
Loading
49 49
50 50
AnyConverter::AnyConverter(PluginManager::Manager<AbstractConverter>& manager): AbstractConverter{manager} {}
51 51
52 -
AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{Containers::InPlaceInit} {}
52 +
AnyConverter::AnyConverter(PluginManager::AbstractManager& manager, const std::string& plugin): AbstractConverter{manager, plugin}, _state{InPlaceInit} {}
53 53
54 54
AnyConverter::~AnyConverter() = default;
55 55

@@ -92,25 +92,25 @@
Loading
92 92
    Containers::ArrayView<TransformFeedbackState> transformFeedbackStateView;
93 93
    #endif
94 94
    Containers::ArrayTuple data{
95 -
        {Containers::NoInit, 1, stateView},
96 -
        {Containers::NoInit, 1, bufferStateView},
97 -
        {Containers::NoInit, 1, contextStateView},
95 +
        {NoInit, 1, stateView},
96 +
        {NoInit, 1, bufferStateView},
97 +
        {NoInit, 1, contextStateView},
98 98
        #ifndef MAGNUM_TARGET_WEBGL
99 -
        {Containers::NoInit, 1, debugStateView},
99 +
        {NoInit, 1, debugStateView},
100 100
        #endif
101 -
        {Containers::NoInit, 1, framebufferStateView},
102 -
        {Containers::NoInit, 1, meshStateView},
103 -
        {Containers::NoInit, 1, queryStateView},
104 -
        {Containers::NoInit, 1, rendererStateView},
105 -
        {Containers::NoInit, 1, shaderStateView},
106 -
        {Containers::NoInit, 1, shaderProgramStateView},
107 -
        {Containers::NoInit, 1, textureStateView},
108 -
        {Containers::ValueInit, std::size_t(maxTextureUnits), textureBindings},
101 +
        {NoInit, 1, framebufferStateView},
102 +
        {NoInit, 1, meshStateView},
103 +
        {NoInit, 1, queryStateView},
104 +
        {NoInit, 1, rendererStateView},
105 +
        {NoInit, 1, shaderStateView},
106 +
        {NoInit, 1, shaderProgramStateView},
107 +
        {NoInit, 1, textureStateView},
108 +
        {ValueInit, std::size_t(maxTextureUnits), textureBindings},
109 109
        #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
110 -
        {Containers::ValueInit, std::size_t(maxImageUnits), imageBindings},
110 +
        {ValueInit, std::size_t(maxImageUnits), imageBindings},
111 111
        #endif
112 112
        #ifndef MAGNUM_TARGET_GLES2
113 -
        {Containers::NoInit, 1, transformFeedbackStateView}
113 +
        {NoInit, 1, transformFeedbackStateView}
114 114
        #endif
115 115
    };
116 116

@@ -76,7 +76,7 @@
Loading
76 76
}
77 77
78 78
Containers::Array<UnsignedInt> generateLineStripIndices(const UnsignedInt vertexCount) {
79 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, 2*(vertexCount - 1)};
79 +
    Containers::Array<UnsignedInt> indices{NoInit, 2*(vertexCount - 1)};
80 80
    generateLineStripIndicesInto(vertexCount, indices);
81 81
    return indices;
82 82
}
@@ -105,7 +105,7 @@
Loading
105 105
}
106 106
107 107
Containers::Array<UnsignedInt> generateLineLoopIndices(const UnsignedInt vertexCount) {
108 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, 2*vertexCount};
108 +
    Containers::Array<UnsignedInt> indices{NoInit, 2*vertexCount};
109 109
    generateLineLoopIndicesInto(vertexCount, indices);
110 110
    return indices;
111 111
}
@@ -134,7 +134,7 @@
Loading
134 134
}
135 135
136 136
Containers::Array<UnsignedInt> generateTriangleStripIndices(const UnsignedInt vertexCount) {
137 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, 3*(vertexCount - 2)};
137 +
    Containers::Array<UnsignedInt> indices{NoInit, 3*(vertexCount - 2)};
138 138
    generateTriangleStripIndicesInto(vertexCount, indices);
139 139
    return indices;
140 140
}
@@ -164,7 +164,7 @@
Loading
164 164
}
165 165
166 166
Containers::Array<UnsignedInt> generateTriangleFanIndices(const UnsignedInt vertexCount) {
167 -
    Containers::Array<UnsignedInt> indices{Containers::NoInit, 3*(vertexCount - 2)};
167 +
    Containers::Array<UnsignedInt> indices{NoInit, 3*(vertexCount - 2)};
168 168
    generateTriangleFanIndicesInto(vertexCount, indices);
169 169
    return indices;
170 170
}
@@ -216,14 +216,14 @@
Loading
216 216
217 217
Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedInt>& quads) {
218 218
    /* We can skip zero-initialization here */
219 -
    Containers::Array<UnsignedInt> out{Containers::NoInit, quads.size()*6/4};
219 +
    Containers::Array<UnsignedInt> out{NoInit, quads.size()*6/4};
220 220
    generateQuadIndicesIntoImplementation(positions, quads, Containers::stridedArrayView(out));
221 221
    return out;
222 222
}
223 223
224 224
Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedShort>& quads) {
225 225
    /* Explicitly ensure we have the unused bytes zeroed out */
226 -
    Containers::Array<UnsignedInt> out{Containers::ValueInit, quads.size()*6/4};
226 +
    Containers::Array<UnsignedInt> out{ValueInit, quads.size()*6/4};
227 227
    generateQuadIndicesIntoImplementation(positions, quads,
228 228
        /* Could be just arrayCast<UnsignedShort>(stridedArrayView(out) on LE,
229 229
           but I want to be sure as much as possible that this compiles on BE
@@ -241,7 +241,7 @@
Loading
241 241
242 242
Containers::Array<UnsignedInt> generateQuadIndices(const Containers::StridedArrayView1D<const Vector3>& positions, const Containers::StridedArrayView1D<const UnsignedByte>& quads) {
243 243
    /* Explicitly ensure we have the unused bytes zeroed out */
244 -
    Containers::Array<UnsignedInt> out{Containers::ValueInit, quads.size()*6/4};
244 +
    Containers::Array<UnsignedInt> out{ValueInit, quads.size()*6/4};
245 245
    generateQuadIndicesIntoImplementation(positions, quads,
246 246
        /* Could be just arrayCast<UnsignedShort>(stridedArrayView(out) on LE,
247 247
           but I want to be sure as much as possible that this compiles on BE
@@ -281,7 +281,7 @@
Loading
281 281
    if(data.vertexDataFlags() & Trade::DataFlag::Owned)
282 282
        vertexData = data.releaseVertexData();
283 283
    else {
284 -
        vertexData = Containers::Array<char>{Containers::NoInit, data.vertexData().size()};
284 +
        vertexData = Containers::Array<char>{NoInit, data.vertexData().size()};
285 285
        Utility::copy(data.vertexData(), vertexData);
286 286
    }
287 287
@@ -301,19 +301,19 @@
Loading
301 301
    Containers::Array<char> indexData;
302 302
    if(data.primitive() == MeshPrimitive::LineStrip) {
303 303
        primitive = MeshPrimitive::Lines;
304 -
        indexData = Containers::Array<char>{Containers::NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)};
304 +
        indexData = Containers::Array<char>{NoInit, 2*(vertexCount - 1)*sizeof(UnsignedInt)};
305 305
        generateLineStripIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
306 306
    } else if(data.primitive() == MeshPrimitive::LineLoop) {
307 307
        primitive = MeshPrimitive::Lines;
308 -
        indexData = Containers::Array<char>{Containers::NoInit, 2*vertexCount*sizeof(UnsignedInt)};
308 +
        indexData = Containers::Array<char>{NoInit, 2*vertexCount*sizeof(UnsignedInt)};
309 309
        generateLineLoopIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
310 310
    } else if(data.primitive() == MeshPrimitive::TriangleStrip) {
311 311
        primitive = MeshPrimitive::Triangles;
312 -
        indexData = Containers::Array<char>{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
312 +
        indexData = Containers::Array<char>{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
313 313
        generateTriangleStripIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
314 314
    } else if(data.primitive() == MeshPrimitive::TriangleFan) {
315 315
        primitive = MeshPrimitive::Triangles;
316 -
        indexData = Containers::Array<char>{Containers::NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
316 +
        indexData = Containers::Array<char>{NoInit, 3*(vertexCount - 2)*sizeof(UnsignedInt)};
317 317
        generateTriangleFanIndicesInto(vertexCount, Containers::arrayCast<UnsignedInt>(indexData));
318 318
    } else CORRADE_ASSERT_UNREACHABLE("MeshTools::generateIndices(): invalid primitive" << data.primitive(),
319 319
        (Trade::MeshData{MeshPrimitive::Triangles, 0}));

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

@@ -64,8 +64,8 @@
Loading
64 64
template<class IndexType, class Vertex, class Interpolator> void subdivide(Containers::Array<IndexType>& indices, Containers::Array<Vertex>& vertices, Interpolator interpolator) {
65 65
    CORRADE_ASSERT(!(indices.size()%3), "MeshTools::subdivide(): index count is not divisible by 3", );
66 66
67 -
    arrayResize(vertices, Containers::NoInit, vertices.size() + indices.size());
68 -
    arrayResize(indices, Containers::NoInit, indices.size()*4);
67 +
    arrayResize(vertices, NoInit, vertices.size() + indices.size());
68 +
    arrayResize(indices, NoInit, indices.size()*4);
69 69
    subdivideInPlace(Containers::stridedArrayView(indices), Containers::stridedArrayView(vertices), interpolator);
70 70
}
71 71

@@ -48,7 +48,7 @@
Loading
48 48
49 49
    Containers::ArrayView<VkDescriptorPoolSize> poolSizesCopy;
50 50
    _data = Containers::ArrayTuple{
51 -
        {Containers::NoInit, poolSizes.size(), poolSizesCopy}
51 +
        {NoInit, poolSizes.size(), poolSizesCopy}
52 52
    };
53 53
    for(std::size_t i = 0; i != poolSizes.size(); ++i) {
54 54
        CORRADE_ASSERT(poolSizes[i].second,

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

@@ -164,7 +164,7 @@
Loading
164 164
        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} {}
165 165
166 166
        /** @overload */
167 -
        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} {}
167 +
        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} {}
168 168
169 169
        /** @overload
170 170
         * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolator, Extrapolation, Extrapolation)
@@ -173,7 +173,7 @@
Loading
173 173
        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} {}
174 174
175 175
        /** @overload */
176 -
        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} {}
176 +
        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} {}
177 177
178 178
        /**
179 179
         * @brief Construct with both generic and custom interpolator
@@ -192,7 +192,7 @@
Loading
192 192
        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} {}
193 193
194 194
        /** @overload */
195 -
        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} {}
195 +
        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} {}
196 196
197 197
        /** @overload
198 198
         * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolation, Interpolator, Extrapolation, Extrapolation)
@@ -201,7 +201,7 @@
Loading
201 201
        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} {}
202 202
203 203
        /** @overload */
204 -
        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} {}
204 +
        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} {}
205 205
206 206
        /**
207 207
         * @brief Construct with generic interpolation behavior
@@ -219,7 +219,7 @@
Loading
219 219
        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} {}
220 220
221 221
        /** @overload */
222 -
        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} {}
222 +
        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} {}
223 223
224 224
        /** @overload
225 225
         * Equivalent to calling @ref Track(Containers::Array<std::pair<K, V>>&&, Interpolation, Extrapolation, Extrapolation)
@@ -228,7 +228,7 @@
Loading
228 228
        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} {}
229 229
230 230
        /** @overload */
231 -
        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} {}
231 +
        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} {}
232 232
233 233
        /** @brief Copying is not allowed */
234 234
        Track(const Track<K, V, R>&) = delete;

@@ -61,8 +61,8 @@
Loading
61 61
    /* Get locations and storage classes for all entrypoint interfaces */
62 62
    Containers::ArrayView<ShaderTools::Implementation::SpirvEntrypointInterface> vertexInterface, fragmentInterface;
63 63
    Containers::ArrayTuple interfaceData{
64 -
        {Containers::ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface},
65 -
        {Containers::ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface}
64 +
        {ValueInit, vertexEntryPoint->interfaces.size(), vertexInterface},
65 +
        {ValueInit, fragmentEntryPoint->interfaces.size(), fragmentInterface}
66 66
    };
67 67
    spirvEntrypointInterface(data, *vertexEntryPoint, vertexInterface);
68 68
    spirvEntrypointInterface(data, *fragmentEntryPoint, fragmentInterface);

@@ -379,7 +379,7 @@
Loading
379 379
        UnsignedInt count;
380 380
        _state->getQueueFamilyPropertiesImplementation(*this, count, nullptr);
381 381
382 -
        _state->queueFamilyProperties = Containers::Array<VkQueueFamilyProperties2>{Containers::ValueInit, count};
382 +
        _state->queueFamilyProperties = Containers::Array<VkQueueFamilyProperties2>{ValueInit, count};
383 383
        for(VkQueueFamilyProperties2& i: _state->queueFamilyProperties)
384 384
            i.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
385 385
        _state->getQueueFamilyPropertiesImplementation(*this, count, _state->queueFamilyProperties);
@@ -587,7 +587,7 @@
Loading
587 587
588 588
    /* Fetch device handles, expect the device count didn't change between
589 589
       calls */
590 -
    Containers::Array<DeviceProperties> out{Containers::NoInit, count};
590 +
    Containers::Array<DeviceProperties> out{NoInit, count};
591 591
    CORRADE_INTERNAL_ASSERT_OUTPUT(Implementation::enumerateDevicesInto(instance, out) == out.size());
592 592
593 593
    return out;
@@ -599,7 +599,7 @@
Loading
599 599
600 600
    /* Pick the first by default */
601 601
    if(args.value("device").empty()) {
602 -
        Containers::Array1<DeviceProperties> devices{Containers::NoInit};
602 +
        Containers::Array1<DeviceProperties> devices{NoInit};
603 603
        if(!Implementation::enumerateDevicesInto(instance, devices)) {
604 604
            Error{} << "Vk::tryPickDevice(): no Vulkan devices found";
605 605
            return {};
@@ -611,7 +611,7 @@
Loading
611 611
    /* Pick by ID */
612 612
    if(args.value("device")[0] >= '0' && args.value("device")[0] <= '9') {
613 613
        const UnsignedInt id = args.value<UnsignedInt>("device");
614 -
        Containers::Array<DeviceProperties> devices{Containers::NoInit, id + 1};
614 +
        Containers::Array<DeviceProperties> devices{NoInit, id + 1};
615 615
        const UnsignedInt count = Implementation::enumerateDevicesInto(instance, devices);
616 616
        if(id >= count) {
617 617
            Error{} << "Vk::tryPickDevice(): index" << id << "out of bounds for" << count << "Vulkan devices";

@@ -45,7 +45,7 @@
Loading
45 45
       the end be in interval neighbors[neighborOffset[i]] ;
46 46
       neighbors[neighborOffset[i+1]]. Currently the values are shifted to
47 47
       right, because the next loop will shift them back left. */
48 -
    neighborOffset = Containers::Array<UnsignedInt>{Containers::NoInit, vertexCount + 1};
48 +
    neighborOffset = Containers::Array<UnsignedInt>{NoInit, vertexCount + 1};
49 49
    neighborOffset[0] = 0;
50 50
    UnsignedInt sum = 0;
51 51
    for(std::size_t i = 0; i != vertexCount; ++i) {
@@ -55,7 +55,7 @@
Loading
55 55
56 56
    /* Array of neighbors, using (and changing) neighborOffset array for
57 57
       positioning */
58 -
    neighbors = Containers::Array<UnsignedInt>{Containers::NoInit, sum};
58 +
    neighbors = Containers::Array<UnsignedInt>{NoInit, sum};
59 59
    for(std::size_t i = 0; i != indices.size(); ++i)
60 60
        neighbors[neighborOffset[indices[i]+1]++] = i/3;
61 61
}

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

@@ -49,7 +49,7 @@
Loading
49 49
    Containers::Array<UnsignedInt> deadEndStack;
50 50
51 51
    /* Output index buffer */
52 -
    Containers::Array<T> outputIndices{Containers::NoInit, indices.size()};
52 +
    Containers::Array<T> outputIndices{NoInit, indices.size()};
53 53
    std::size_t outputIndex = 0;
54 54
55 55
    /* Array with candidates for next fanning vertex (in 1-ring around

@@ -216,7 +216,7 @@
Loading
216 216
        return Trade::MeshData{data.primitive(), vertexCount};
217 217
218 218
    /* Allocate new data array */
219 -
    Containers::Array<char> vertexData{Containers::NoInit, attributeData[0].stride()*vertexCount};
219 +
    Containers::Array<char> vertexData{NoInit, attributeData[0].stride()*vertexCount};
220 220
221 221
    /* Convert the attributes from offset-only and zero vertex count to
222 222
       absolute, referencing the above-allocated data array */
Files Coverage
src 79.97%
Project Totals (504 files) 79.97%
2407
Build #2407 -
2406
Build #2406 -
2409
Build #2409 -
2408
Build #2408 -
2410
Build #2410 -
2405
Build #2405 -
2411
Build #2411 -
2417
Build #2417 -
s5mrygb8vx102p5a

No yaml found.

Create your codecov.yml to customize your Codecov experience

Sunburst
The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
Icicle
The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.
Grid
Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.
Loading