Coverage Report

Created: 2026-10-19 15:26

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/tmp/bitcoin/src/prevector.h
Line
Count
Source
1
// Copyright (c) 2015-present The Bitcoin Core developers
2
// Distributed under the MIT software license, see the accompanying
3
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5
#ifndef BITCOIN_PREVECTOR_H
6
#define BITCOIN_PREVECTOR_H
7
8
#include <algorithm>
9
#include <cassert>
10
#include <cstdint>
11
#include <cstdlib>
12
#include <cstring>
13
#include <iterator>
14
#include <new>
15
#include <type_traits>
16
#include <utility>
17
18
/** Implements a drop-in replacement for std::vector<T> which stores up to N
19
 *  elements directly (without heap allocation). The types Size and Diff are
20
 *  used to store element counts, and can be any unsigned + signed type.
21
 *
22
 *  Storage layout is either:
23
 *  - Direct allocation:
24
 *    - Size _size: the number of used elements (between 0 and N)
25
 *    - T direct[N]: an array of N elements of type T
26
 *      (only the first _size are initialized).
27
 *  - Indirect allocation:
28
 *    - Size _size: the number of used elements plus N + 1
29
 *    - Size capacity: the number of allocated elements
30
 *    - T* indirect: a pointer to an array of capacity elements of type T
31
 *      (only the first _size are initialized).
32
 *
33
 *  The data type T must be movable by memmove/realloc(). Once we switch to C++,
34
 *  move constructors can be used instead.
35
 */
36
template<unsigned int N, typename T, typename Size = uint32_t, typename Diff = int32_t>
37
class prevector {
38
    static_assert(std::is_trivially_copyable_v<T>);
39
40
public:
41
    static constexpr unsigned int STATIC_SIZE{N};
42
43
    typedef Size size_type;
44
    typedef Diff difference_type;
45
    typedef T value_type;
46
    typedef value_type& reference;
47
    typedef const value_type& const_reference;
48
    typedef value_type* pointer;
49
    typedef const value_type* const_pointer;
50
51
    class iterator {
52
        T* ptr{};
53
    public:
54
        typedef Diff difference_type;
55
        typedef T* pointer;
56
        typedef T& reference;
57
        using element_type = T;
58
        using iterator_category = std::contiguous_iterator_tag;
59
        iterator() = default;
60
91.1M
        iterator(T* ptr_) : ptr(ptr_) {}
prevector<36u, unsigned char, unsigned int, int>::iterator::iterator(unsigned char*)
Line
Count
Source
60
76.3M
        iterator(T* ptr_) : ptr(ptr_) {}
prevector<16u, unsigned char, unsigned int, int>::iterator::iterator(unsigned char*)
Line
Count
Source
60
497k
        iterator(T* ptr_) : ptr(ptr_) {}
prevector<8u, int, unsigned int, int>::iterator::iterator(int*)
Line
Count
Source
60
14.3M
        iterator(T* ptr_) : ptr(ptr_) {}
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::iterator::iterator(unsigned char*)
prevector<35u, unsigned char, unsigned int, int>::iterator::iterator(unsigned char*)
Line
Count
Source
60
1.19k
        iterator(T* ptr_) : ptr(ptr_) {}
61
151M
        T& operator*() const { return *ptr; }
prevector<36u, unsigned char, unsigned int, int>::iterator::operator*() const
Line
Count
Source
61
139M
        T& operator*() const { return *ptr; }
prevector<16u, unsigned char, unsigned int, int>::iterator::operator*() const
Line
Count
Source
61
994k
        T& operator*() const { return *ptr; }
prevector<8u, int, unsigned int, int>::iterator::operator*() const
Line
Count
Source
61
11.2M
        T& operator*() const { return *ptr; }
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::iterator::operator*() const
prevector<35u, unsigned char, unsigned int, int>::iterator::operator*() const
Line
Count
Source
61
1.19k
        T& operator*() const { return *ptr; }
62
36.0k
        T* operator->() const { return ptr; }
Unexecuted instantiation: prevector<16u, unsigned char, unsigned int, int>::iterator::operator->() const
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::iterator::operator->() const
prevector<36u, unsigned char, unsigned int, int>::iterator::operator->() const
Line
Count
Source
62
36.0k
        T* operator->() const { return ptr; }
Unexecuted instantiation: prevector<35u, unsigned char, unsigned int, int>::iterator::operator->() const
63
2.03M
        T& operator[](size_type pos) const { return ptr[pos]; }
64
41.7M
        iterator& operator++() { ptr++; return *this; }
prevector<36u, unsigned char, unsigned int, int>::iterator::operator++()
Line
Count
Source
64
37.7M
        iterator& operator++() { ptr++; return *this; }
prevector<8u, int, unsigned int, int>::iterator::operator++()
Line
Count
Source
64
4.07M
        iterator& operator++() { ptr++; return *this; }
65
4.07M
        iterator& operator--() { ptr--; return *this; }
66
        iterator operator++(int) { iterator copy(*this); ++(*this); return copy; }
67
        iterator operator--(int) { iterator copy(*this); --(*this); return copy; }
68
27.5M
        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
68
27.0M
        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<16u, unsigned char, unsigned int, int>::iterator, prevector<16u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
68
165k
        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<8u, int, unsigned int, int>::iterator, prevector<8u, int, unsigned int, int>::iterator)
Line
Count
Source
68
388k
        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
Unexecuted instantiation: operator-(prevector<33u, unsigned char, unsigned int, int>::iterator, prevector<33u, unsigned char, unsigned int, int>::iterator)
operator-(prevector<35u, unsigned char, unsigned int, int>::iterator, prevector<35u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
68
596
        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
69
4.22M
        iterator operator+(size_type n) const { return iterator(ptr + n); }
70
        iterator friend operator+(size_type n, iterator x) { return x + n; }
71
        iterator& operator+=(size_type n) { ptr += n; return *this; }
72
2.04M
        iterator operator-(size_type n) const { return iterator(ptr - n); }
73
        iterator& operator-=(size_type n) { ptr -= n; return *this; }
74
44.7M
        bool operator==(iterator x) const { return ptr == x.ptr; }
prevector<36u, unsigned char, unsigned int, int>::iterator::operator==(prevector<36u, unsigned char, unsigned int, int>::iterator) const
Line
Count
Source
74
37.8M
        bool operator==(iterator x) const { return ptr == x.ptr; }
prevector<8u, int, unsigned int, int>::iterator::operator==(prevector<8u, int, unsigned int, int>::iterator) const
Line
Count
Source
74
6.91M
        bool operator==(iterator x) const { return ptr == x.ptr; }
75
0
        auto operator<=>(iterator x) const { return ptr <=> x.ptr; }
Unexecuted instantiation: prevector<16u, unsigned char, unsigned int, int>::iterator::operator<=>(prevector<16u, unsigned char, unsigned int, int>::iterator) const
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::iterator::operator<=>(prevector<33u, unsigned char, unsigned int, int>::iterator) const
Unexecuted instantiation: prevector<36u, unsigned char, unsigned int, int>::iterator::operator<=>(prevector<36u, unsigned char, unsigned int, int>::iterator) const
Unexecuted instantiation: prevector<8u, int, unsigned int, int>::iterator::operator<=>(prevector<8u, int, unsigned int, int>::iterator) const
Unexecuted instantiation: prevector<35u, unsigned char, unsigned int, int>::iterator::operator<=>(prevector<35u, unsigned char, unsigned int, int>::iterator) const
76
    };
77
78
    class const_iterator {
79
        const T* ptr{};
80
    public:
81
        typedef Diff difference_type;
82
        typedef const T* pointer;
83
        typedef const T& reference;
84
        using element_type = const T;
85
        using iterator_category = std::contiguous_iterator_tag;
86
        const_iterator() = default;
87
1.83G
        const_iterator(const T* ptr_) : ptr(ptr_) {}
prevector<16u, unsigned char, unsigned int, int>::const_iterator::const_iterator(unsigned char const*)
Line
Count
Source
87
7.46M
        const_iterator(const T* ptr_) : ptr(ptr_) {}
prevector<36u, unsigned char, unsigned int, int>::const_iterator::const_iterator(unsigned char const*)
Line
Count
Source
87
1.82G
        const_iterator(const T* ptr_) : ptr(ptr_) {}
prevector<8u, int, unsigned int, int>::const_iterator::const_iterator(int const*)
Line
Count
Source
87
3.73M
        const_iterator(const T* ptr_) : ptr(ptr_) {}
88
757k
        const_iterator(iterator x) : ptr(&(*x)) {}
89
18.4G
        const T& operator*() const { return *ptr; }
prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator*() const
Line
Count
Source
89
18.4G
        const T& operator*() const { return *ptr; }
prevector<16u, unsigned char, unsigned int, int>::const_iterator::operator*() const
Line
Count
Source
89
11.9M
        const T& operator*() const { return *ptr; }
prevector<8u, int, unsigned int, int>::const_iterator::operator*() const
Line
Count
Source
89
16.4M
        const T& operator*() const { return *ptr; }
90
3.99M
        const T* operator->() const { return ptr; }
prevector<16u, unsigned char, unsigned int, int>::const_iterator::operator->() const
Line
Count
Source
90
610
        const T* operator->() const { return ptr; }
prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator->() const
Line
Count
Source
90
3.99M
        const T* operator->() const { return ptr; }
91
185k
        const T& operator[](size_type pos) const { return ptr[pos]; }
92
16.4G
        const_iterator& operator++() { ptr++; return *this; }
prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator++()
Line
Count
Source
92
16.4G
        const_iterator& operator++() { ptr++; return *this; }
prevector<16u, unsigned char, unsigned int, int>::const_iterator::operator++()
Line
Count
Source
92
6.49M
        const_iterator& operator++() { ptr++; return *this; }
prevector<8u, int, unsigned int, int>::const_iterator::operator++()
Line
Count
Source
92
12.2M
        const_iterator& operator++() { ptr++; return *this; }
93
4.07M
        const_iterator& operator--() { ptr--; return *this; }
prevector<8u, int, unsigned int, int>::const_iterator::operator--()
Line
Count
Source
93
4.07M
        const_iterator& operator--() { ptr--; return *this; }
Unexecuted instantiation: prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator--()
94
805M
        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }
95
        const_iterator operator--(int) { const_iterator copy(*this); --(*this); return copy; }
96
857M
        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<36u, unsigned char, unsigned int, int>::const_iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
96
855M
        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<16u, unsigned char, unsigned int, int>::const_iterator, prevector<16u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
96
485k
        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
operator-(prevector<8u, int, unsigned int, int>::const_iterator, prevector<8u, int, unsigned int, int>::const_iterator)
Line
Count
Source
96
1.07M
        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
97
6.10M
        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
98
        const_iterator friend operator+(size_type n, const_iterator x) { return x + n; }
99
9.34M
        const_iterator& operator+=(size_type n) { ptr += n; return *this; }
100
590
        const_iterator operator-(size_type n) const { return const_iterator(ptr - n); }
101
        const_iterator& operator-=(size_type n) { ptr -= n; return *this; }
102
15.5G
        bool operator==(const_iterator x) const { return ptr == x.ptr; }
prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator==(prevector<36u, unsigned char, unsigned int, int>::const_iterator) const
Line
Count
Source
102
15.5G
        bool operator==(const_iterator x) const { return ptr == x.ptr; }
prevector<16u, unsigned char, unsigned int, int>::const_iterator::operator==(prevector<16u, unsigned char, unsigned int, int>::const_iterator) const
Line
Count
Source
102
7.36M
        bool operator==(const_iterator x) const { return ptr == x.ptr; }
prevector<8u, int, unsigned int, int>::const_iterator::operator==(prevector<8u, int, unsigned int, int>::const_iterator) const
Line
Count
Source
102
11.5M
        bool operator==(const_iterator x) const { return ptr == x.ptr; }
103
1.60G
        auto operator<=>(const_iterator x) const { return ptr <=> x.ptr; }
Unexecuted instantiation: prevector<16u, unsigned char, unsigned int, int>::const_iterator::operator<=>(prevector<16u, unsigned char, unsigned int, int>::const_iterator) const
prevector<36u, unsigned char, unsigned int, int>::const_iterator::operator<=>(prevector<36u, unsigned char, unsigned int, int>::const_iterator) const
Line
Count
Source
103
1.60G
        auto operator<=>(const_iterator x) const { return ptr <=> x.ptr; }
Unexecuted instantiation: prevector<8u, int, unsigned int, int>::const_iterator::operator<=>(prevector<8u, int, unsigned int, int>::const_iterator) const
104
    };
105
106
private:
107
#pragma pack(push, 1)
108
    union direct_or_indirect {
109
        char direct[sizeof(T) * N];
110
        struct {
111
            char* indirect;
112
            size_type capacity;
113
        } indirect_contents;
114
    };
115
#pragma pack(pop)
116
    alignas(char*) direct_or_indirect _union = {};
117
    size_type _size = 0;
118
119
    static_assert(alignof(char*) % alignof(size_type) == 0 && sizeof(char*) % alignof(size_type) == 0, "size_type cannot have more restrictive alignment requirement than pointer");
120
    static_assert(alignof(char*) % alignof(T) == 0, "value_type T cannot have more restrictive alignment requirement than pointer");
121
122
124M
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<36u, unsigned char, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
118M
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<16u, unsigned char, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
2.18M
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<33u, unsigned char, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
781k
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<8u, int, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
2.86M
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<4u, Network, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
1.17k
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
prevector<35u, unsigned char, unsigned int, int>::direct_ptr(int)
Line
Count
Source
122
2.38k
    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
123
300M
    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
prevector<36u, unsigned char, unsigned int, int>::direct_ptr(int) const
Line
Count
Source
123
281M
    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
prevector<16u, unsigned char, unsigned int, int>::direct_ptr(int) const
Line
Count
Source
123
17.0M
    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
prevector<8u, int, unsigned int, int>::direct_ptr(int) const
Line
Count
Source
123
1.58M
    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
prevector<33u, unsigned char, unsigned int, int>::direct_ptr(int) const
Line
Count
Source
123
133k
    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
124
34.7M
    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
prevector<36u, unsigned char, unsigned int, int>::indirect_ptr(int)
Line
Count
Source
124
20.5M
    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
prevector<16u, unsigned char, unsigned int, int>::indirect_ptr(int)
Line
Count
Source
124
2.91k
    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::indirect_ptr(int)
prevector<8u, int, unsigned int, int>::indirect_ptr(int)
Line
Count
Source
124
14.2M
    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
Unexecuted instantiation: prevector<4u, Network, unsigned int, int>::indirect_ptr(int)
Unexecuted instantiation: prevector<35u, unsigned char, unsigned int, int>::indirect_ptr(int)
125
1.58G
    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
prevector<36u, unsigned char, unsigned int, int>::indirect_ptr(int) const
Line
Count
Source
125
1.58G
    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
prevector<16u, unsigned char, unsigned int, int>::indirect_ptr(int) const
Line
Count
Source
125
7.87k
    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
prevector<8u, int, unsigned int, int>::indirect_ptr(int) const
Line
Count
Source
125
2.14M
    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::indirect_ptr(int) const
126
4.66G
    bool is_direct() const { return _size <= N; }
prevector<36u, unsigned char, unsigned int, int>::is_direct() const
Line
Count
Source
126
4.60G
    bool is_direct() const { return _size <= N; }
prevector<16u, unsigned char, unsigned int, int>::is_direct() const
Line
Count
Source
126
32.0M
    bool is_direct() const { return _size <= N; }
prevector<33u, unsigned char, unsigned int, int>::is_direct() const
Line
Count
Source
126
2.20M
    bool is_direct() const { return _size <= N; }
prevector<8u, int, unsigned int, int>::is_direct() const
Line
Count
Source
126
28.8M
    bool is_direct() const { return _size <= N; }
prevector<4u, Network, unsigned int, int>::is_direct() const
Line
Count
Source
126
4.69k
    bool is_direct() const { return _size <= N; }
prevector<35u, unsigned char, unsigned int, int>::is_direct() const
Line
Count
Source
126
5.66k
    bool is_direct() const { return _size <= N; }
127
128
131M
    void change_capacity(size_type new_capacity) {
129
131M
        if (new_capacity <= N) {
130
128M
            if (!is_direct()) {
131
44.8k
                T* indirect = indirect_ptr(0);
132
44.8k
                T* src = indirect;
133
44.8k
                T* dst = direct_ptr(0);
134
44.8k
                memcpy(dst, src, size() * sizeof(T));
135
44.8k
                free(indirect);
136
44.8k
                _size -= N + 1;
137
44.8k
            }
138
128M
        } else {
139
2.44M
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
82.8k
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
82.8k
                assert(_union.indirect_contents.indirect);
145
82.8k
                _union.indirect_contents.capacity = new_capacity;
146
2.36M
            } else {
147
2.36M
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
2.36M
                assert(new_indirect);
149
2.36M
                T* src = direct_ptr(0);
150
2.36M
                T* dst = reinterpret_cast<T*>(new_indirect);
151
2.36M
                memcpy(dst, src, size() * sizeof(T));
152
2.36M
                _union.indirect_contents.indirect = new_indirect;
153
2.36M
                _union.indirect_contents.capacity = new_capacity;
154
2.36M
                _size += N + 1;
155
2.36M
            }
156
2.44M
        }
157
131M
    }
prevector<36u, unsigned char, unsigned int, int>::change_capacity(unsigned int)
Line
Count
Source
128
129M
    void change_capacity(size_type new_capacity) {
129
129M
        if (new_capacity <= N) {
130
126M
            if (!is_direct()) {
131
44.2k
                T* indirect = indirect_ptr(0);
132
44.2k
                T* src = indirect;
133
44.2k
                T* dst = direct_ptr(0);
134
44.2k
                memcpy(dst, src, size() * sizeof(T));
135
44.2k
                free(indirect);
136
44.2k
                _size -= N + 1;
137
44.2k
            }
138
126M
        } else {
139
2.24M
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
78.7k
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
78.7k
                assert(_union.indirect_contents.indirect);
145
78.7k
                _union.indirect_contents.capacity = new_capacity;
146
2.16M
            } else {
147
2.16M
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
2.16M
                assert(new_indirect);
149
2.16M
                T* src = direct_ptr(0);
150
2.16M
                T* dst = reinterpret_cast<T*>(new_indirect);
151
2.16M
                memcpy(dst, src, size() * sizeof(T));
152
2.16M
                _union.indirect_contents.indirect = new_indirect;
153
2.16M
                _union.indirect_contents.capacity = new_capacity;
154
2.16M
                _size += N + 1;
155
2.16M
            }
156
2.24M
        }
157
129M
    }
prevector<16u, unsigned char, unsigned int, int>::change_capacity(unsigned int)
Line
Count
Source
128
1.52M
    void change_capacity(size_type new_capacity) {
129
1.52M
        if (new_capacity <= N) {
130
1.51M
            if (!is_direct()) {
131
0
                T* indirect = indirect_ptr(0);
132
0
                T* src = indirect;
133
0
                T* dst = direct_ptr(0);
134
0
                memcpy(dst, src, size() * sizeof(T));
135
0
                free(indirect);
136
0
                _size -= N + 1;
137
0
            }
138
1.51M
        } else {
139
2.58k
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
0
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
0
                assert(_union.indirect_contents.indirect);
145
0
                _union.indirect_contents.capacity = new_capacity;
146
2.58k
            } else {
147
2.58k
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
2.58k
                assert(new_indirect);
149
2.58k
                T* src = direct_ptr(0);
150
2.58k
                T* dst = reinterpret_cast<T*>(new_indirect);
151
2.58k
                memcpy(dst, src, size() * sizeof(T));
152
2.58k
                _union.indirect_contents.indirect = new_indirect;
153
2.58k
                _union.indirect_contents.capacity = new_capacity;
154
2.58k
                _size += N + 1;
155
2.58k
            }
156
2.58k
        }
157
1.52M
    }
prevector<33u, unsigned char, unsigned int, int>::change_capacity(unsigned int)
Line
Count
Source
128
133k
    void change_capacity(size_type new_capacity) {
129
133k
        if (new_capacity <= N) {
130
133k
            if (!is_direct()) {
131
0
                T* indirect = indirect_ptr(0);
132
0
                T* src = indirect;
133
0
                T* dst = direct_ptr(0);
134
0
                memcpy(dst, src, size() * sizeof(T));
135
0
                free(indirect);
136
0
                _size -= N + 1;
137
0
            }
138
133k
        } else {
139
0
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
0
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
0
                assert(_union.indirect_contents.indirect);
145
0
                _union.indirect_contents.capacity = new_capacity;
146
0
            } else {
147
0
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
0
                assert(new_indirect);
149
0
                T* src = direct_ptr(0);
150
0
                T* dst = reinterpret_cast<T*>(new_indirect);
151
0
                memcpy(dst, src, size() * sizeof(T));
152
0
                _union.indirect_contents.indirect = new_indirect;
153
0
                _union.indirect_contents.capacity = new_capacity;
154
0
                _size += N + 1;
155
0
            }
156
0
        }
157
133k
    }
prevector<8u, int, unsigned int, int>::change_capacity(unsigned int)
Line
Count
Source
128
540k
    void change_capacity(size_type new_capacity) {
129
540k
        if (new_capacity <= N) {
130
339k
            if (!is_direct()) {
131
623
                T* indirect = indirect_ptr(0);
132
623
                T* src = indirect;
133
623
                T* dst = direct_ptr(0);
134
623
                memcpy(dst, src, size() * sizeof(T));
135
623
                free(indirect);
136
623
                _size -= N + 1;
137
623
            }
138
339k
        } else {
139
201k
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
4.16k
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
4.16k
                assert(_union.indirect_contents.indirect);
145
4.16k
                _union.indirect_contents.capacity = new_capacity;
146
197k
            } else {
147
197k
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
197k
                assert(new_indirect);
149
197k
                T* src = direct_ptr(0);
150
197k
                T* dst = reinterpret_cast<T*>(new_indirect);
151
197k
                memcpy(dst, src, size() * sizeof(T));
152
197k
                _union.indirect_contents.indirect = new_indirect;
153
197k
                _union.indirect_contents.capacity = new_capacity;
154
197k
                _size += N + 1;
155
197k
            }
156
201k
        }
157
540k
    }
Unexecuted instantiation: prevector<4u, Network, unsigned int, int>::change_capacity(unsigned int)
prevector<35u, unsigned char, unsigned int, int>::change_capacity(unsigned int)
Line
Count
Source
128
298
    void change_capacity(size_type new_capacity) {
129
298
        if (new_capacity <= N) {
130
298
            if (!is_direct()) {
131
0
                T* indirect = indirect_ptr(0);
132
0
                T* src = indirect;
133
0
                T* dst = direct_ptr(0);
134
0
                memcpy(dst, src, size() * sizeof(T));
135
0
                free(indirect);
136
0
                _size -= N + 1;
137
0
            }
138
298
        } else {
139
0
            if (!is_direct()) {
140
                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
141
                    success. These should instead use an allocator or new/delete so that handlers
142
                    are called as necessary, but performance would be slightly degraded by doing so. */
143
0
                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
144
0
                assert(_union.indirect_contents.indirect);
145
0
                _union.indirect_contents.capacity = new_capacity;
146
0
            } else {
147
0
                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
148
0
                assert(new_indirect);
149
0
                T* src = direct_ptr(0);
150
0
                T* dst = reinterpret_cast<T*>(new_indirect);
151
0
                memcpy(dst, src, size() * sizeof(T));
152
0
                _union.indirect_contents.indirect = new_indirect;
153
0
                _union.indirect_contents.capacity = new_capacity;
154
0
                _size += N + 1;
155
0
            }
156
0
        }
157
298
    }
158
159
156M
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<36u, unsigned char, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
137M
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<16u, unsigned char, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
2.18M
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<33u, unsigned char, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
781k
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<8u, int, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
16.9M
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<4u, Network, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
1.17k
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<35u, unsigned char, unsigned int, int>::item_ptr(int)
Line
Count
Source
159
2.38k
    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
160
1.88G
    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<36u, unsigned char, unsigned int, int>::item_ptr(int) const
Line
Count
Source
160
1.86G
    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<16u, unsigned char, unsigned int, int>::item_ptr(int) const
Line
Count
Source
160
17.0M
    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<8u, int, unsigned int, int>::item_ptr(int) const
Line
Count
Source
160
3.73M
    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
prevector<33u, unsigned char, unsigned int, int>::item_ptr(int) const
Line
Count
Source
160
133k
    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
161
162
1.23M
    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
163
1.23M
        std::fill_n(dst, count, value);
164
1.23M
    }
prevector<36u, unsigned char, unsigned int, int>::fill(unsigned char*, long, unsigned char const&)
Line
Count
Source
162
596k
    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
163
596k
        std::fill_n(dst, count, value);
164
596k
    }
prevector<16u, unsigned char, unsigned int, int>::fill(unsigned char*, long, unsigned char const&)
Line
Count
Source
162
357k
    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
163
357k
        std::fill_n(dst, count, value);
164
357k
    }
prevector<33u, unsigned char, unsigned int, int>::fill(unsigned char*, long, unsigned char const&)
Line
Count
Source
162
262k
    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
163
262k
        std::fill_n(dst, count, value);
164
262k
    }
prevector<8u, int, unsigned int, int>::fill(int*, long, int const&)
Line
Count
Source
162
22.9k
    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
163
22.9k
        std::fill_n(dst, count, value);
164
22.9k
    }
165
166
    template <std::input_iterator InputIterator>
167
59.4M
    void fill(T* dst, InputIterator first, InputIterator last) {
168
15.5G
        while (first != last) {
169
15.4G
            new(static_cast<void*>(dst)) T(*first);
170
15.4G
            ++dst;
171
15.4G
            ++first;
172
15.4G
        }
173
59.4M
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<unsigned char const*>(unsigned char*, unsigned char const*, unsigned char const*)
Line
Count
Source
167
393
    void fill(T* dst, InputIterator first, InputIterator last) {
168
1.42k
        while (first != last) {
169
1.02k
            new(static_cast<void*>(dst)) T(*first);
170
1.02k
            ++dst;
171
1.02k
            ++first;
172
1.02k
        }
173
393
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
167
2.81M
    void fill(T* dst, InputIterator first, InputIterator last) {
168
90.0M
        while (first != last) {
169
87.2M
            new(static_cast<void*>(dst)) T(*first);
170
87.2M
            ++dst;
171
87.2M
            ++first;
172
87.2M
        }
173
2.81M
    }
void prevector<16u, unsigned char, unsigned int, int>::fill<prevector<16u, unsigned char, unsigned int, int>::const_iterator>(unsigned char*, prevector<16u, unsigned char, unsigned int, int>::const_iterator, prevector<16u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
167
1.21M
    void fill(T* dst, InputIterator first, InputIterator last) {
168
6.50M
        while (first != last) {
169
5.28M
            new(static_cast<void*>(dst)) T(*first);
170
5.28M
            ++dst;
171
5.28M
            ++first;
172
5.28M
        }
173
1.21M
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<prevector<36u, unsigned char, unsigned int, int>::const_iterator>(unsigned char*, prevector<36u, unsigned char, unsigned int, int>::const_iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
167
54.4M
    void fill(T* dst, InputIterator first, InputIterator last) {
168
15.3G
        while (first != last) {
169
15.3G
            new(static_cast<void*>(dst)) T(*first);
170
15.3G
            ++dst;
171
15.3G
            ++first;
172
15.3G
        }
173
54.4M
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
167
222k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
29.2M
        while (first != last) {
169
29.0M
            new(static_cast<void*>(dst)) T(*first);
170
29.0M
            ++dst;
171
29.0M
            ++first;
172
29.0M
        }
173
222k
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
167
41.7k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
1.74M
        while (first != last) {
169
1.70M
            new(static_cast<void*>(dst)) T(*first);
170
1.70M
            ++dst;
171
1.70M
            ++first;
172
1.70M
        }
173
41.7k
    }
void prevector<33u, unsigned char, unsigned int, int>::fill<unsigned char*>(unsigned char*, unsigned char*, unsigned char*)
Line
Count
Source
167
1
    void fill(T* dst, InputIterator first, InputIterator last) {
168
33
        while (first != last) {
169
32
            new(static_cast<void*>(dst)) T(*first);
170
32
            ++dst;
171
32
            ++first;
172
32
        }
173
1
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<prevector<36u, unsigned char, unsigned int, int>::iterator>(unsigned char*, prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
167
23.0k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
37.3M
        while (first != last) {
169
37.3M
            new(static_cast<void*>(dst)) T(*first);
170
37.3M
            ++dst;
171
37.3M
            ++first;
172
37.3M
        }
173
23.0k
    }
void prevector<8u, int, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(int*, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>)
Line
Count
Source
167
265k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
2.30M
        while (first != last) {
169
2.03M
            new(static_cast<void*>(dst)) T(*first);
170
2.03M
            ++dst;
171
2.03M
            ++first;
172
2.03M
        }
173
265k
    }
void prevector<8u, int, unsigned int, int>::fill<prevector<8u, int, unsigned int, int>::iterator>(int*, prevector<8u, int, unsigned int, int>::iterator, prevector<8u, int, unsigned int, int>::iterator)
Line
Count
Source
167
265k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
2.30M
        while (first != last) {
169
2.03M
            new(static_cast<void*>(dst)) T(*first);
170
2.03M
            ++dst;
171
2.03M
            ++first;
172
2.03M
        }
173
265k
    }
void prevector<8u, int, unsigned int, int>::fill<int*>(int*, int*, int*)
Line
Count
Source
167
3.96k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
14.0k
        while (first != last) {
169
10.0k
            new(static_cast<void*>(dst)) T(*first);
170
10.0k
            ++dst;
171
10.0k
            ++first;
172
10.0k
        }
173
3.96k
    }
void prevector<8u, int, unsigned int, int>::fill<prevector<8u, int, unsigned int, int>::const_iterator>(int*, prevector<8u, int, unsigned int, int>::const_iterator, prevector<8u, int, unsigned int, int>::const_iterator)
Line
Count
Source
167
8.13k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
53.7k
        while (first != last) {
169
45.5k
            new(static_cast<void*>(dst)) T(*first);
170
45.5k
            ++dst;
171
45.5k
            ++first;
172
45.5k
        }
173
8.13k
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>)
Line
Count
Source
167
7
    void fill(T* dst, InputIterator first, InputIterator last) {
168
35
        while (first != last) {
169
28
            new(static_cast<void*>(dst)) T(*first);
170
28
            ++dst;
171
28
            ++first;
172
28
        }
173
7
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>)
Line
Count
Source
167
4
    void fill(T* dst, InputIterator first, InputIterator last) {
168
36
        while (first != last) {
169
32
            new(static_cast<void*>(dst)) T(*first);
170
32
            ++dst;
171
32
            ++first;
172
32
        }
173
4
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>)
Line
Count
Source
167
6
    void fill(T* dst, InputIterator first, InputIterator last) {
168
12
        while (first != last) {
169
6
            new(static_cast<void*>(dst)) T(*first);
170
6
            ++dst;
171
6
            ++first;
172
6
        }
173
6
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>)
Line
Count
Source
167
2
    void fill(T* dst, InputIterator first, InputIterator last) {
168
12
        while (first != last) {
169
10
            new(static_cast<void*>(dst)) T(*first);
170
10
            ++dst;
171
10
            ++first;
172
10
        }
173
2
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>)
Line
Count
Source
167
7
    void fill(T* dst, InputIterator first, InputIterator last) {
168
28
        while (first != last) {
169
21
            new(static_cast<void*>(dst)) T(*first);
170
21
            ++dst;
171
21
            ++first;
172
21
        }
173
7
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>)
Line
Count
Source
167
2
    void fill(T* dst, InputIterator first, InputIterator last) {
168
16
        while (first != last) {
169
14
            new(static_cast<void*>(dst)) T(*first);
170
14
            ++dst;
171
14
            ++first;
172
14
        }
173
2
    }
void prevector<36u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>)
Line
Count
Source
167
2
    void fill(T* dst, InputIterator first, InputIterator last) {
168
52
        while (first != last) {
169
50
            new(static_cast<void*>(dst)) T(*first);
170
50
            ++dst;
171
50
            ++first;
172
50
        }
173
2
    }
void prevector<16u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
167
10.3k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
96.3k
        while (first != last) {
169
85.9k
            new(static_cast<void*>(dst)) T(*first);
170
85.9k
            ++dst;
171
85.9k
            ++first;
172
85.9k
        }
173
10.3k
    }
void prevector<16u, unsigned char, unsigned int, int>::fill<unsigned char*>(unsigned char*, unsigned char*, unsigned char*)
Line
Count
Source
167
10
    void fill(T* dst, InputIterator first, InputIterator last) {
168
110
        while (first != last) {
169
100
            new(static_cast<void*>(dst)) T(*first);
170
100
            ++dst;
171
100
            ++first;
172
100
        }
173
10
    }
void prevector<16u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
167
41
    void fill(T* dst, InputIterator first, InputIterator last) {
168
1.35k
        while (first != last) {
169
1.31k
            new(static_cast<void*>(dst)) T(*first);
170
1.31k
            ++dst;
171
1.31k
            ++first;
172
1.31k
        }
173
41
    }
void prevector<16u, unsigned char, unsigned int, int>::fill<unsigned char const*>(unsigned char*, unsigned char const*, unsigned char const*)
Line
Count
Source
167
61.0k
    void fill(T* dst, InputIterator first, InputIterator last) {
168
305k
        while (first != last) {
169
244k
            new(static_cast<void*>(dst)) T(*first);
170
244k
            ++dst;
171
244k
            ++first;
172
244k
        }
173
61.0k
    }
void prevector<35u, unsigned char, unsigned int, int>::fill<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(unsigned char*, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
167
298
    void fill(T* dst, InputIterator first, InputIterator last) {
168
9.83k
        while (first != last) {
169
9.53k
            new(static_cast<void*>(dst)) T(*first);
170
9.53k
            ++dst;
171
9.53k
            ++first;
172
9.53k
        }
173
298
    }
void prevector<35u, unsigned char, unsigned int, int>::fill<unsigned char*>(unsigned char*, unsigned char*, unsigned char*)
Line
Count
Source
167
298
    void fill(T* dst, InputIterator first, InputIterator last) {
168
894
        while (first != last) {
169
596
            new(static_cast<void*>(dst)) T(*first);
170
596
            ++dst;
171
596
            ++first;
172
596
        }
173
298
    }
void prevector<35u, unsigned char, unsigned int, int>::fill<unsigned char const*>(unsigned char*, unsigned char const*, unsigned char const*)
Line
Count
Source
167
298
    void fill(T* dst, InputIterator first, InputIterator last) {
168
596
        while (first != last) {
169
298
            new(static_cast<void*>(dst)) T(*first);
170
298
            ++dst;
171
298
            ++first;
172
298
        }
173
298
    }
174
175
public:
176
144k
    void assign(size_type n, const T& val) {
177
144k
        clear();
178
144k
        if (capacity() < n) {
179
94.4k
            change_capacity(n);
180
94.4k
        }
181
144k
        _size += n;
182
144k
        fill(item_ptr(0), n, val);
183
144k
    }
prevector<36u, unsigned char, unsigned int, int>::assign(unsigned int, unsigned char const&)
Line
Count
Source
176
143k
    void assign(size_type n, const T& val) {
177
143k
        clear();
178
143k
        if (capacity() < n) {
179
94.3k
            change_capacity(n);
180
94.3k
        }
181
143k
        _size += n;
182
143k
        fill(item_ptr(0), n, val);
183
143k
    }
prevector<16u, unsigned char, unsigned int, int>::assign(unsigned int, unsigned char const&)
Line
Count
Source
176
6
    void assign(size_type n, const T& val) {
177
6
        clear();
178
6
        if (capacity() < n) {
179
0
            change_capacity(n);
180
0
        }
181
6
        _size += n;
182
6
        fill(item_ptr(0), n, val);
183
6
    }
prevector<8u, int, unsigned int, int>::assign(unsigned int, int const&)
Line
Count
Source
176
256
    void assign(size_type n, const T& val) {
177
256
        clear();
178
256
        if (capacity() < n) {
179
121
            change_capacity(n);
180
121
        }
181
256
        _size += n;
182
256
        fill(item_ptr(0), n, val);
183
256
    }
184
185
    template <std::input_iterator InputIterator>
186
2.30M
    void assign(InputIterator first, InputIterator last) {
187
2.30M
        size_type n = last - first;
188
2.30M
        clear();
189
2.30M
        if (capacity() < n) {
190
122k
            change_capacity(n);
191
122k
        }
192
2.30M
        _size += n;
193
2.30M
        fill(item_ptr(0), first, last);
194
2.30M
    }
void prevector<16u, unsigned char, unsigned int, int>::assign<prevector<16u, unsigned char, unsigned int, int>::const_iterator>(prevector<16u, unsigned char, unsigned int, int>::const_iterator, prevector<16u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
186
52.5k
    void assign(InputIterator first, InputIterator last) {
187
52.5k
        size_type n = last - first;
188
52.5k
        clear();
189
52.5k
        if (capacity() < n) {
190
65
            change_capacity(n);
191
65
        }
192
52.5k
        _size += n;
193
52.5k
        fill(item_ptr(0), first, last);
194
52.5k
    }
void prevector<36u, unsigned char, unsigned int, int>::assign<prevector<36u, unsigned char, unsigned int, int>::const_iterator>(prevector<36u, unsigned char, unsigned int, int>::const_iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
186
2.16M
    void assign(InputIterator first, InputIterator last) {
187
2.16M
        size_type n = last - first;
188
2.16M
        clear();
189
2.16M
        if (capacity() < n) {
190
121k
            change_capacity(n);
191
121k
        }
192
2.16M
        _size += n;
193
2.16M
        fill(item_ptr(0), first, last);
194
2.16M
    }
void prevector<8u, int, unsigned int, int>::assign<prevector<8u, int, unsigned int, int>::const_iterator>(prevector<8u, int, unsigned int, int>::const_iterator, prevector<8u, int, unsigned int, int>::const_iterator)
Line
Count
Source
186
8.13k
    void assign(InputIterator first, InputIterator last) {
187
8.13k
        size_type n = last - first;
188
8.13k
        clear();
189
8.13k
        if (capacity() < n) {
190
601
            change_capacity(n);
191
601
        }
192
8.13k
        _size += n;
193
8.13k
        fill(item_ptr(0), first, last);
194
8.13k
    }
void prevector<16u, unsigned char, unsigned int, int>::assign<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
186
10.3k
    void assign(InputIterator first, InputIterator last) {
187
10.3k
        size_type n = last - first;
188
10.3k
        clear();
189
10.3k
        if (capacity() < n) {
190
85
            change_capacity(n);
191
85
        }
192
10.3k
        _size += n;
193
10.3k
        fill(item_ptr(0), first, last);
194
10.3k
    }
void prevector<16u, unsigned char, unsigned int, int>::assign<unsigned char*>(unsigned char*, unsigned char*)
Line
Count
Source
186
10
    void assign(InputIterator first, InputIterator last) {
187
10
        size_type n = last - first;
188
10
        clear();
189
10
        if (capacity() < n) {
190
0
            change_capacity(n);
191
0
        }
192
10
        _size += n;
193
10
        fill(item_ptr(0), first, last);
194
10
    }
void prevector<16u, unsigned char, unsigned int, int>::assign<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
186
41
    void assign(InputIterator first, InputIterator last) {
187
41
        size_type n = last - first;
188
41
        clear();
189
41
        if (capacity() < n) {
190
40
            change_capacity(n);
191
40
        }
192
41
        _size += n;
193
41
        fill(item_ptr(0), first, last);
194
41
    }
void prevector<16u, unsigned char, unsigned int, int>::assign<unsigned char const*>(unsigned char const*, unsigned char const*)
Line
Count
Source
186
61.0k
    void assign(InputIterator first, InputIterator last) {
187
61.0k
        size_type n = last - first;
188
61.0k
        clear();
189
61.0k
        if (capacity() < n) {
190
0
            change_capacity(n);
191
0
        }
192
61.0k
        _size += n;
193
61.0k
        fill(item_ptr(0), first, last);
194
61.0k
    }
195
196
83.7M
    prevector() = default;
prevector<36u, unsigned char, unsigned int, int>::prevector()
Line
Count
Source
196
83.2M
    prevector() = default;
prevector<33u, unsigned char, unsigned int, int>::prevector()
Line
Count
Source
196
505k
    prevector() = default;
prevector<8u, int, unsigned int, int>::prevector()
Line
Count
Source
196
128
    prevector() = default;
prevector<4u, Network, unsigned int, int>::prevector()
Line
Count
Source
196
394
    prevector() = default;
197
198
    explicit prevector(size_type n) {
199
        resize(n);
200
    }
201
202
490k
    explicit prevector(size_type n, const T& val) {
203
490k
        change_capacity(n);
204
490k
        _size += n;
205
490k
        fill(item_ptr(0), n, val);
206
490k
    }
prevector<33u, unsigned char, unsigned int, int>::prevector(unsigned int, unsigned char const&)
Line
Count
Source
202
133k
    explicit prevector(size_type n, const T& val) {
203
133k
        change_capacity(n);
204
133k
        _size += n;
205
133k
        fill(item_ptr(0), n, val);
206
133k
    }
prevector<16u, unsigned char, unsigned int, int>::prevector(unsigned int, unsigned char const&)
Line
Count
Source
202
357k
    explicit prevector(size_type n, const T& val) {
203
357k
        change_capacity(n);
204
357k
        _size += n;
205
357k
        fill(item_ptr(0), n, val);
206
357k
    }
207
208
    template <std::input_iterator InputIterator>
209
1.18M
    prevector(InputIterator first, InputIterator last) {
210
1.18M
        size_type n = last - first;
211
1.18M
        change_capacity(n);
212
1.18M
        _size += n;
213
1.18M
        fill(item_ptr(0), first, last);
214
1.18M
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
209
222k
    prevector(InputIterator first, InputIterator last) {
210
222k
        size_type n = last - first;
211
222k
        change_capacity(n);
212
222k
        _size += n;
213
222k
        fill(item_ptr(0), first, last);
214
222k
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
209
38.9k
    prevector(InputIterator first, InputIterator last) {
210
38.9k
        size_type n = last - first;
211
38.9k
        change_capacity(n);
212
38.9k
        _size += n;
213
38.9k
        fill(item_ptr(0), first, last);
214
38.9k
    }
prevector<33u, unsigned char, unsigned int, int>::prevector<unsigned char*>(unsigned char*, unsigned char*)
Line
Count
Source
209
1
    prevector(InputIterator first, InputIterator last) {
210
1
        size_type n = last - first;
211
1
        change_capacity(n);
212
1
        _size += n;
213
1
        fill(item_ptr(0), first, last);
214
1
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<unsigned char const*>(unsigned char const*, unsigned char const*)
Line
Count
Source
209
13
    prevector(InputIterator first, InputIterator last) {
210
13
        size_type n = last - first;
211
13
        change_capacity(n);
212
13
        _size += n;
213
13
        fill(item_ptr(0), first, last);
214
13
    }
prevector<8u, int, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>)
Line
Count
Source
209
265k
    prevector(InputIterator first, InputIterator last) {
210
265k
        size_type n = last - first;
211
265k
        change_capacity(n);
212
265k
        _size += n;
213
265k
        fill(item_ptr(0), first, last);
214
265k
    }
prevector<8u, int, unsigned int, int>::prevector<prevector<8u, int, unsigned int, int>::iterator>(prevector<8u, int, unsigned int, int>::iterator, prevector<8u, int, unsigned int, int>::iterator)
Line
Count
Source
209
265k
    prevector(InputIterator first, InputIterator last) {
210
265k
        size_type n = last - first;
211
265k
        change_capacity(n);
212
265k
        _size += n;
213
265k
        fill(item_ptr(0), first, last);
214
265k
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
209
8.19k
    prevector(InputIterator first, InputIterator last) {
210
8.19k
        size_type n = last - first;
211
8.19k
        change_capacity(n);
212
8.19k
        _size += n;
213
8.19k
        fill(item_ptr(0), first, last);
214
8.19k
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 4ul>::__iter_tag>)
Line
Count
Source
209
7
    prevector(InputIterator first, InputIterator last) {
210
7
        size_type n = last - first;
211
7
        change_capacity(n);
212
7
        _size += n;
213
7
        fill(item_ptr(0), first, last);
214
7
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 8ul>::__iter_tag>)
Line
Count
Source
209
4
    prevector(InputIterator first, InputIterator last) {
210
4
        size_type n = last - first;
211
4
        change_capacity(n);
212
4
        _size += n;
213
4
        fill(item_ptr(0), first, last);
214
4
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 1ul>::__iter_tag>)
Line
Count
Source
209
6
    prevector(InputIterator first, InputIterator last) {
210
6
        size_type n = last - first;
211
6
        change_capacity(n);
212
6
        _size += n;
213
6
        fill(item_ptr(0), first, last);
214
6
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 5ul>::__iter_tag>)
Line
Count
Source
209
2
    prevector(InputIterator first, InputIterator last) {
210
2
        size_type n = last - first;
211
2
        change_capacity(n);
212
2
        _size += n;
213
2
        fill(item_ptr(0), first, last);
214
2
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 3ul>::__iter_tag>)
Line
Count
Source
209
7
    prevector(InputIterator first, InputIterator last) {
210
7
        size_type n = last - first;
211
7
        change_capacity(n);
212
7
        _size += n;
213
7
        fill(item_ptr(0), first, last);
214
7
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 7ul>::__iter_tag>)
Line
Count
Source
209
2
    prevector(InputIterator first, InputIterator last) {
210
2
        size_type n = last - first;
211
2
        change_capacity(n);
212
2
        _size += n;
213
2
        fill(item_ptr(0), first, last);
214
2
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 25ul>::__iter_tag>)
Line
Count
Source
209
2
    prevector(InputIterator first, InputIterator last) {
210
2
        size_type n = last - first;
211
2
        change_capacity(n);
212
2
        _size += n;
213
2
        fill(item_ptr(0), first, last);
214
2
    }
prevector<36u, unsigned char, unsigned int, int>::prevector<prevector<36u, unsigned char, unsigned int, int>::const_iterator>(prevector<36u, unsigned char, unsigned int, int>::const_iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
209
379k
    prevector(InputIterator first, InputIterator last) {
210
379k
        size_type n = last - first;
211
379k
        change_capacity(n);
212
379k
        _size += n;
213
379k
        fill(item_ptr(0), first, last);
214
379k
    }
prevector<35u, unsigned char, unsigned int, int>::prevector<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
209
298
    prevector(InputIterator first, InputIterator last) {
210
298
        size_type n = last - first;
211
298
        change_capacity(n);
212
298
        _size += n;
213
298
        fill(item_ptr(0), first, last);
214
298
    }
215
216
50.3M
    prevector(const prevector<N, T, Size, Diff>& other) {
217
50.3M
        size_type n = other.size();
218
50.3M
        change_capacity(n);
219
50.3M
        _size += n;
220
50.3M
        fill(item_ptr(0), other.begin(),  other.end());
221
50.3M
    }
prevector<16u, unsigned char, unsigned int, int>::prevector(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
216
1.16M
    prevector(const prevector<N, T, Size, Diff>& other) {
217
1.16M
        size_type n = other.size();
218
1.16M
        change_capacity(n);
219
1.16M
        _size += n;
220
1.16M
        fill(item_ptr(0), other.begin(),  other.end());
221
1.16M
    }
prevector<36u, unsigned char, unsigned int, int>::prevector(prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
216
49.1M
    prevector(const prevector<N, T, Size, Diff>& other) {
217
49.1M
        size_type n = other.size();
218
49.1M
        change_capacity(n);
219
49.1M
        _size += n;
220
49.1M
        fill(item_ptr(0), other.begin(),  other.end());
221
49.1M
    }
222
223
    prevector(prevector<N, T, Size, Diff>&& other) noexcept
224
16.3M
        : _union(std::move(other._union)), _size(other._size)
225
16.3M
    {
226
16.3M
        other._size = 0;
227
16.3M
    }
prevector<16u, unsigned char, unsigned int, int>::prevector(prevector<16u, unsigned char, unsigned int, int>&&)
Line
Count
Source
224
29.6k
        : _union(std::move(other._union)), _size(other._size)
225
29.6k
    {
226
29.6k
        other._size = 0;
227
29.6k
    }
prevector<36u, unsigned char, unsigned int, int>::prevector(prevector<36u, unsigned char, unsigned int, int>&&)
Line
Count
Source
224
16.3M
        : _union(std::move(other._union)), _size(other._size)
225
16.3M
    {
226
16.3M
        other._size = 0;
227
16.3M
    }
228
229
2.24M
    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
230
2.24M
        if (&other == this) {
231
13.1k
            return *this;
232
13.1k
        }
233
2.22M
        assign(other.begin(), other.end());
234
2.22M
        return *this;
235
2.24M
    }
prevector<16u, unsigned char, unsigned int, int>::operator=(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
229
52.5k
    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
230
52.5k
        if (&other == this) {
231
2
            return *this;
232
2
        }
233
52.5k
        assign(other.begin(), other.end());
234
52.5k
        return *this;
235
52.5k
    }
prevector<36u, unsigned char, unsigned int, int>::operator=(prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
229
2.18M
    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
230
2.18M
        if (&other == this) {
231
13.1k
            return *this;
232
13.1k
        }
233
2.16M
        assign(other.begin(), other.end());
234
2.16M
        return *this;
235
2.18M
    }
prevector<8u, int, unsigned int, int>::operator=(prevector<8u, int, unsigned int, int> const&)
Line
Count
Source
229
8.13k
    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
230
8.13k
        if (&other == this) {
231
0
            return *this;
232
0
        }
233
8.13k
        assign(other.begin(), other.end());
234
8.13k
        return *this;
235
8.13k
    }
236
237
34.4M
    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
238
34.4M
        if (!is_direct()) {
239
24.8k
            free(_union.indirect_contents.indirect);
240
24.8k
        }
241
34.4M
        _union = std::move(other._union);
242
34.4M
        _size = other._size;
243
34.4M
        other._size = 0;
244
34.4M
        return *this;
245
34.4M
    }
prevector<16u, unsigned char, unsigned int, int>::operator=(prevector<16u, unsigned char, unsigned int, int>&&)
Line
Count
Source
237
91.7k
    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
238
91.7k
        if (!is_direct()) {
239
8
            free(_union.indirect_contents.indirect);
240
8
        }
241
91.7k
        _union = std::move(other._union);
242
91.7k
        _size = other._size;
243
91.7k
        other._size = 0;
244
91.7k
        return *this;
245
91.7k
    }
prevector<36u, unsigned char, unsigned int, int>::operator=(prevector<36u, unsigned char, unsigned int, int>&&)
Line
Count
Source
237
34.4M
    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
238
34.4M
        if (!is_direct()) {
239
22.2k
            free(_union.indirect_contents.indirect);
240
22.2k
        }
241
34.4M
        _union = std::move(other._union);
242
34.4M
        _size = other._size;
243
34.4M
        other._size = 0;
244
34.4M
        return *this;
245
34.4M
    }
prevector<8u, int, unsigned int, int>::operator=(prevector<8u, int, unsigned int, int>&&)
Line
Count
Source
237
4.11k
    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
238
4.11k
        if (!is_direct()) {
239
2.56k
            free(_union.indirect_contents.indirect);
240
2.56k
        }
241
4.11k
        _union = std::move(other._union);
242
4.11k
        _size = other._size;
243
4.11k
        other._size = 0;
244
4.11k
        return *this;
245
4.11k
    }
246
247
2.24G
    size_type size() const {
248
2.24G
        return is_direct() ? _size : _size - N - 1;
249
2.24G
    }
prevector<36u, unsigned char, unsigned int, int>::size() const
Line
Count
Source
247
2.22G
    size_type size() const {
248
2.22G
        return is_direct() ? _size : _size - N - 1;
249
2.22G
    }
prevector<16u, unsigned char, unsigned int, int>::size() const
Line
Count
Source
247
9.59M
    size_type size() const {
248
9.59M
        return is_direct() ? _size : _size - N - 1;
249
9.59M
    }
prevector<33u, unsigned char, unsigned int, int>::size() const
Line
Count
Source
247
390k
    size_type size() const {
248
390k
        return is_direct() ? _size : _size - N - 1;
249
390k
    }
prevector<8u, int, unsigned int, int>::size() const
Line
Count
Source
247
7.04M
    size_type size() const {
248
7.04M
        return is_direct() ? _size : _size - N - 1;
249
7.04M
    }
prevector<4u, Network, unsigned int, int>::size() const
Line
Count
Source
247
2.34k
    size_type size() const {
248
2.34k
        return is_direct() ? _size : _size - N - 1;
249
2.34k
    }
prevector<35u, unsigned char, unsigned int, int>::size() const
Line
Count
Source
247
2.08k
    size_type size() const {
248
2.08k
        return is_direct() ? _size : _size - N - 1;
249
2.08k
    }
250
251
35.5M
    bool empty() const {
252
35.5M
        return size() == 0;
253
35.5M
    }
prevector<36u, unsigned char, unsigned int, int>::empty() const
Line
Count
Source
251
35.2M
    bool empty() const {
252
35.2M
        return size() == 0;
253
35.2M
    }
prevector<16u, unsigned char, unsigned int, int>::empty() const
Line
Count
Source
251
100k
    bool empty() const {
252
100k
        return size() == 0;
253
100k
    }
prevector<8u, int, unsigned int, int>::empty() const
Line
Count
Source
251
265k
    bool empty() const {
252
265k
        return size() == 0;
253
265k
    }
prevector<4u, Network, unsigned int, int>::empty() const
Line
Count
Source
251
394
    bool empty() const {
252
394
        return size() == 0;
253
394
    }
254
255
21.0M
    iterator begin() { return iterator(item_ptr(0)); }
prevector<36u, unsigned char, unsigned int, int>::begin()
Line
Count
Source
255
15.9M
    iterator begin() { return iterator(item_ptr(0)); }
Unexecuted instantiation: prevector<16u, unsigned char, unsigned int, int>::begin()
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::begin()
prevector<8u, int, unsigned int, int>::begin()
Line
Count
Source
255
5.04M
    iterator begin() { return iterator(item_ptr(0)); }
prevector<35u, unsigned char, unsigned int, int>::begin()
Line
Count
Source
255
596
    iterator begin() { return iterator(item_ptr(0)); }
256
146M
    const_iterator begin() const { return const_iterator(item_ptr(0)); }
prevector<36u, unsigned char, unsigned int, int>::begin() const
Line
Count
Source
256
138M
    const_iterator begin() const { return const_iterator(item_ptr(0)); }
prevector<16u, unsigned char, unsigned int, int>::begin() const
Line
Count
Source
256
5.79M
    const_iterator begin() const { return const_iterator(item_ptr(0)); }
prevector<8u, int, unsigned int, int>::begin() const
Line
Count
Source
256
1.86M
    const_iterator begin() const { return const_iterator(item_ptr(0)); }
257
42.3M
    iterator end() { return iterator(item_ptr(size())); }
prevector<36u, unsigned char, unsigned int, int>::end()
Line
Count
Source
257
39.0M
    iterator end() { return iterator(item_ptr(size())); }
prevector<16u, unsigned char, unsigned int, int>::end()
Line
Count
Source
257
331k
    iterator end() { return iterator(item_ptr(size())); }
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::end()
prevector<8u, int, unsigned int, int>::end()
Line
Count
Source
257
2.93M
    iterator end() { return iterator(item_ptr(size())); }
prevector<35u, unsigned char, unsigned int, int>::end()
Line
Count
Source
257
596
    iterator end() { return iterator(item_ptr(size())); }
258
1.68G
    const_iterator end() const { return const_iterator(item_ptr(size())); }
prevector<36u, unsigned char, unsigned int, int>::end() const
Line
Count
Source
258
1.68G
    const_iterator end() const { return const_iterator(item_ptr(size())); }
prevector<16u, unsigned char, unsigned int, int>::end() const
Line
Count
Source
258
1.67M
    const_iterator end() const { return const_iterator(item_ptr(size())); }
prevector<8u, int, unsigned int, int>::end() const
Line
Count
Source
258
1.86M
    const_iterator end() const { return const_iterator(item_ptr(size())); }
259
260
19.5M
    size_t capacity() const {
261
19.5M
        if (is_direct()) {
262
13.6M
            return N;
263
13.6M
        } else {
264
5.88M
            return _union.indirect_contents.capacity;
265
5.88M
        }
266
19.5M
    }
prevector<36u, unsigned char, unsigned int, int>::capacity() const
Line
Count
Source
260
19.1M
    size_t capacity() const {
261
19.1M
        if (is_direct()) {
262
13.3M
            return N;
263
13.3M
        } else {
264
5.82M
            return _union.indirect_contents.capacity;
265
5.82M
        }
266
19.1M
    }
prevector<16u, unsigned char, unsigned int, int>::capacity() const
Line
Count
Source
260
124k
    size_t capacity() const {
261
124k
        if (is_direct()) {
262
124k
            return N;
263
124k
        } else {
264
10
            return _union.indirect_contents.capacity;
265
10
        }
266
124k
    }
prevector<8u, int, unsigned int, int>::capacity() const
Line
Count
Source
260
92.1k
    size_t capacity() const {
261
92.1k
        if (is_direct()) {
262
33.8k
            return N;
263
58.2k
        } else {
264
58.2k
            return _union.indirect_contents.capacity;
265
58.2k
        }
266
92.1k
    }
prevector<4u, Network, unsigned int, int>::capacity() const
Line
Count
Source
260
780
    size_t capacity() const {
261
780
        if (is_direct()) {
262
780
            return N;
263
780
        } else {
264
0
            return _union.indirect_contents.capacity;
265
0
        }
266
780
    }
prevector<33u, unsigned char, unsigned int, int>::capacity() const
Line
Count
Source
260
128k
    size_t capacity() const {
261
128k
        if (is_direct()) {
262
128k
            return N;
263
128k
        } else {
264
0
            return _union.indirect_contents.capacity;
265
0
        }
266
128k
    }
prevector<35u, unsigned char, unsigned int, int>::capacity() const
Line
Count
Source
260
596
    size_t capacity() const {
261
596
        if (is_direct()) {
262
596
            return N;
263
596
        } else {
264
0
            return _union.indirect_contents.capacity;
265
0
        }
266
596
    }
267
268
10.7M
    T& operator[](size_type pos) {
269
10.7M
        return *item_ptr(pos);
270
10.7M
    }
prevector<36u, unsigned char, unsigned int, int>::operator[](unsigned int)
Line
Count
Source
268
2.22M
    T& operator[](size_type pos) {
269
2.22M
        return *item_ptr(pos);
270
2.22M
    }
prevector<33u, unsigned char, unsigned int, int>::operator[](unsigned int)
Line
Count
Source
268
257k
    T& operator[](size_type pos) {
269
257k
        return *item_ptr(pos);
270
257k
    }
prevector<8u, int, unsigned int, int>::operator[](unsigned int)
Line
Count
Source
268
8.29M
    T& operator[](size_type pos) {
269
8.29M
        return *item_ptr(pos);
270
8.29M
    }
prevector<4u, Network, unsigned int, int>::operator[](unsigned int)
Line
Count
Source
268
394
    T& operator[](size_type pos) {
269
394
        return *item_ptr(pos);
270
394
    }
prevector<16u, unsigned char, unsigned int, int>::operator[](unsigned int)
Line
Count
Source
268
5.46k
    T& operator[](size_type pos) {
269
5.46k
        return *item_ptr(pos);
270
5.46k
    }
271
272
18.6M
    const T& operator[](size_type pos) const {
273
18.6M
        return *item_ptr(pos);
274
18.6M
    }
prevector<16u, unsigned char, unsigned int, int>::operator[](unsigned int) const
Line
Count
Source
272
7.28M
    const T& operator[](size_type pos) const {
273
7.28M
        return *item_ptr(pos);
274
7.28M
    }
prevector<36u, unsigned char, unsigned int, int>::operator[](unsigned int) const
Line
Count
Source
272
11.3M
    const T& operator[](size_type pos) const {
273
11.3M
        return *item_ptr(pos);
274
11.3M
    }
275
276
82.7M
    void resize(size_type new_size) {
277
82.7M
        size_type cur_size = size();
278
82.7M
        if (cur_size == new_size) {
279
70.3M
            return;
280
70.3M
        }
281
12.4M
        if (cur_size > new_size) {
282
11.8M
            erase(item_ptr(new_size), end());
283
11.8M
            return;
284
11.8M
        }
285
588k
        if (new_size > capacity()) {
286
80.8k
            change_capacity(new_size);
287
80.8k
        }
288
588k
        ptrdiff_t increase = new_size - cur_size;
289
588k
        fill(item_ptr(cur_size), increase);
290
588k
        _size += increase;
291
588k
    }
prevector<36u, unsigned char, unsigned int, int>::resize(unsigned int)
Line
Count
Source
276
82.4M
    void resize(size_type new_size) {
277
82.4M
        size_type cur_size = size();
278
82.4M
        if (cur_size == new_size) {
279
70.3M
            return;
280
70.3M
        }
281
12.1M
        if (cur_size > new_size) {
282
11.6M
            erase(item_ptr(new_size), end());
283
11.6M
            return;
284
11.6M
        }
285
452k
        if (new_size > capacity()) {
286
80.2k
            change_capacity(new_size);
287
80.2k
        }
288
452k
        ptrdiff_t increase = new_size - cur_size;
289
452k
        fill(item_ptr(cur_size), increase);
290
452k
        _size += increase;
291
452k
    }
prevector<16u, unsigned char, unsigned int, int>::resize(unsigned int)
Line
Count
Source
276
166k
    void resize(size_type new_size) {
277
166k
        size_type cur_size = size();
278
166k
        if (cur_size == new_size) {
279
102
            return;
280
102
        }
281
166k
        if (cur_size > new_size) {
282
165k
            erase(item_ptr(new_size), end());
283
165k
            return;
284
165k
        }
285
287
        if (new_size > capacity()) {
286
285
            change_capacity(new_size);
287
285
        }
288
287
        ptrdiff_t increase = new_size - cur_size;
289
287
        fill(item_ptr(cur_size), increase);
290
287
        _size += increase;
291
287
    }
prevector<8u, int, unsigned int, int>::resize(unsigned int)
Line
Count
Source
276
28.9k
    void resize(size_type new_size) {
277
28.9k
        size_type cur_size = size();
278
28.9k
        if (cur_size == new_size) {
279
10.2k
            return;
280
10.2k
        }
281
18.6k
        if (cur_size > new_size) {
282
12.3k
            erase(item_ptr(new_size), end());
283
12.3k
            return;
284
12.3k
        }
285
6.39k
        if (new_size > capacity()) {
286
297
            change_capacity(new_size);
287
297
        }
288
6.39k
        ptrdiff_t increase = new_size - cur_size;
289
6.39k
        fill(item_ptr(cur_size), increase);
290
6.39k
        _size += increase;
291
6.39k
    }
prevector<33u, unsigned char, unsigned int, int>::resize(unsigned int)
Line
Count
Source
276
128k
    void resize(size_type new_size) {
277
128k
        size_type cur_size = size();
278
128k
        if (cur_size == new_size) {
279
0
            return;
280
0
        }
281
128k
        if (cur_size > new_size) {
282
0
            erase(item_ptr(new_size), end());
283
0
            return;
284
0
        }
285
128k
        if (new_size > capacity()) {
286
0
            change_capacity(new_size);
287
0
        }
288
128k
        ptrdiff_t increase = new_size - cur_size;
289
128k
        fill(item_ptr(cur_size), increase);
290
128k
        _size += increase;
291
128k
    }
292
293
4.12k
    void reserve(size_type new_capacity) {
294
4.12k
        if (new_capacity > capacity()) {
295
1.83k
            change_capacity(new_capacity);
296
1.83k
        }
297
4.12k
    }
298
299
78.3M
    void shrink_to_fit() {
300
78.3M
        change_capacity(size());
301
78.3M
    }
prevector<36u, unsigned char, unsigned int, int>::shrink_to_fit()
Line
Count
Source
299
78.3M
    void shrink_to_fit() {
300
78.3M
        change_capacity(size());
301
78.3M
    }
prevector<8u, int, unsigned int, int>::shrink_to_fit()
Line
Count
Source
299
1.97k
    void shrink_to_fit() {
300
1.97k
        change_capacity(size());
301
1.97k
    }
302
303
82.1M
    void clear() {
304
82.1M
        resize(0);
305
82.1M
    }
prevector<36u, unsigned char, unsigned int, int>::clear()
Line
Count
Source
303
81.9M
    void clear() {
304
81.9M
        resize(0);
305
81.9M
    }
prevector<16u, unsigned char, unsigned int, int>::clear()
Line
Count
Source
303
124k
    void clear() {
304
124k
        resize(0);
305
124k
    }
prevector<8u, int, unsigned int, int>::clear()
Line
Count
Source
303
12.6k
    void clear() {
304
12.6k
        resize(0);
305
12.6k
    }
306
307
9.67M
    iterator insert(iterator pos, const T& value) {
308
9.67M
        size_type p = pos - begin();
309
9.67M
        size_type new_size = size() + 1;
310
9.67M
        if (capacity() < new_size) {
311
8.03k
            change_capacity(new_size + (new_size >> 1));
312
8.03k
        }
313
9.67M
        T* ptr = item_ptr(p);
314
9.67M
        T* dst = ptr + 1;
315
9.67M
        memmove(dst, ptr, (size() - p) * sizeof(T));
316
9.67M
        _size++;
317
9.67M
        new(static_cast<void*>(ptr)) T(value);
318
9.67M
        return iterator(ptr);
319
9.67M
    }
prevector<36u, unsigned char, unsigned int, int>::insert(prevector<36u, unsigned char, unsigned int, int>::iterator, unsigned char const&)
Line
Count
Source
307
9.64M
    iterator insert(iterator pos, const T& value) {
308
9.64M
        size_type p = pos - begin();
309
9.64M
        size_type new_size = size() + 1;
310
9.64M
        if (capacity() < new_size) {
311
6.65k
            change_capacity(new_size + (new_size >> 1));
312
6.65k
        }
313
9.64M
        T* ptr = item_ptr(p);
314
9.64M
        T* dst = ptr + 1;
315
9.64M
        memmove(dst, ptr, (size() - p) * sizeof(T));
316
9.64M
        _size++;
317
9.64M
        new(static_cast<void*>(ptr)) T(value);
318
9.64M
        return iterator(ptr);
319
9.64M
    }
prevector<8u, int, unsigned int, int>::insert(prevector<8u, int, unsigned int, int>::iterator, int const&)
Line
Count
Source
307
32.5k
    iterator insert(iterator pos, const T& value) {
308
32.5k
        size_type p = pos - begin();
309
32.5k
        size_type new_size = size() + 1;
310
32.5k
        if (capacity() < new_size) {
311
1.37k
            change_capacity(new_size + (new_size >> 1));
312
1.37k
        }
313
32.5k
        T* ptr = item_ptr(p);
314
32.5k
        T* dst = ptr + 1;
315
32.5k
        memmove(dst, ptr, (size() - p) * sizeof(T));
316
32.5k
        _size++;
317
32.5k
        new(static_cast<void*>(ptr)) T(value);
318
32.5k
        return iterator(ptr);
319
32.5k
    }
320
321
16.3k
    void insert(iterator pos, size_type count, const T& value) {
322
16.3k
        size_type p = pos - begin();
323
16.3k
        size_type new_size = size() + count;
324
16.3k
        if (capacity() < new_size) {
325
762
            change_capacity(new_size + (new_size >> 1));
326
762
        }
327
16.3k
        T* ptr = item_ptr(p);
328
16.3k
        T* dst = ptr + count;
329
16.3k
        memmove(dst, ptr, (size() - p) * sizeof(T));
330
16.3k
        _size += count;
331
16.3k
        fill(item_ptr(p), count, value);
332
16.3k
    }
prevector<8u, int, unsigned int, int>::insert(prevector<8u, int, unsigned int, int>::iterator, unsigned int, int const&)
Line
Count
Source
321
16.3k
    void insert(iterator pos, size_type count, const T& value) {
322
16.3k
        size_type p = pos - begin();
323
16.3k
        size_type new_size = size() + count;
324
16.3k
        if (capacity() < new_size) {
325
755
            change_capacity(new_size + (new_size >> 1));
326
755
        }
327
16.3k
        T* ptr = item_ptr(p);
328
16.3k
        T* dst = ptr + count;
329
16.3k
        memmove(dst, ptr, (size() - p) * sizeof(T));
330
16.3k
        _size += count;
331
16.3k
        fill(item_ptr(p), count, value);
332
16.3k
    }
prevector<36u, unsigned char, unsigned int, int>::insert(prevector<36u, unsigned char, unsigned int, int>::iterator, unsigned int, unsigned char const&)
Line
Count
Source
321
7
    void insert(iterator pos, size_type count, const T& value) {
322
7
        size_type p = pos - begin();
323
7
        size_type new_size = size() + count;
324
7
        if (capacity() < new_size) {
325
7
            change_capacity(new_size + (new_size >> 1));
326
7
        }
327
7
        T* ptr = item_ptr(p);
328
7
        T* dst = ptr + count;
329
7
        memmove(dst, ptr, (size() - p) * sizeof(T));
330
7
        _size += count;
331
7
        fill(item_ptr(p), count, value);
332
7
    }
333
334
    template <std::input_iterator InputIterator>
335
5.61M
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
5.61M
        size_type p = pos - begin();
337
5.61M
        difference_type count = last - first;
338
5.61M
        size_type new_size = size() + count;
339
5.61M
        if (capacity() < new_size) {
340
378k
            change_capacity(new_size + (new_size >> 1));
341
378k
        }
342
5.61M
        T* ptr = item_ptr(p);
343
5.61M
        T* dst = ptr + count;
344
5.61M
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
5.61M
        _size += count;
346
5.61M
        fill(ptr, first, last);
347
5.61M
    }
void prevector<36u, unsigned char, unsigned int, int>::insert<unsigned char const*>(prevector<36u, unsigned char, unsigned int, int>::iterator, unsigned char const*, unsigned char const*)
Line
Count
Source
335
380
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
380
        size_type p = pos - begin();
337
380
        difference_type count = last - first;
338
380
        size_type new_size = size() + count;
339
380
        if (capacity() < new_size) {
340
0
            change_capacity(new_size + (new_size >> 1));
341
0
        }
342
380
        T* ptr = item_ptr(p);
343
380
        T* dst = ptr + count;
344
380
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
380
        _size += count;
346
380
        fill(ptr, first, last);
347
380
    }
void prevector<36u, unsigned char, unsigned int, int>::insert<__gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>>(prevector<36u, unsigned char, unsigned int, int>::iterator, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>, __gnu_cxx::__normal_iterator<unsigned char const*, std::span<unsigned char const, 18446744073709551615ul>::__iter_tag>)
Line
Count
Source
335
2.80M
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
2.80M
        size_type p = pos - begin();
337
2.80M
        difference_type count = last - first;
338
2.80M
        size_type new_size = size() + count;
339
2.80M
        if (capacity() < new_size) {
340
232k
            change_capacity(new_size + (new_size >> 1));
341
232k
        }
342
2.80M
        T* ptr = item_ptr(p);
343
2.80M
        T* dst = ptr + count;
344
2.80M
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
2.80M
        _size += count;
346
2.80M
        fill(ptr, first, last);
347
2.80M
    }
void prevector<36u, unsigned char, unsigned int, int>::insert<prevector<36u, unsigned char, unsigned int, int>::iterator>(prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
335
23.0k
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
23.0k
        size_type p = pos - begin();
337
23.0k
        difference_type count = last - first;
338
23.0k
        size_type new_size = size() + count;
339
23.0k
        if (capacity() < new_size) {
340
17.3k
            change_capacity(new_size + (new_size >> 1));
341
17.3k
        }
342
23.0k
        T* ptr = item_ptr(p);
343
23.0k
        T* dst = ptr + count;
344
23.0k
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
23.0k
        _size += count;
346
23.0k
        fill(ptr, first, last);
347
23.0k
    }
void prevector<8u, int, unsigned int, int>::insert<int*>(prevector<8u, int, unsigned int, int>::iterator, int*, int*)
Line
Count
Source
335
3.96k
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
3.96k
        size_type p = pos - begin();
337
3.96k
        difference_type count = last - first;
338
3.96k
        size_type new_size = size() + count;
339
3.96k
        if (capacity() < new_size) {
340
326
            change_capacity(new_size + (new_size >> 1));
341
326
        }
342
3.96k
        T* ptr = item_ptr(p);
343
3.96k
        T* dst = ptr + count;
344
3.96k
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
3.96k
        _size += count;
346
3.96k
        fill(ptr, first, last);
347
3.96k
    }
void prevector<36u, unsigned char, unsigned int, int>::insert<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(prevector<36u, unsigned char, unsigned int, int>::iterator, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>)
Line
Count
Source
335
2.80k
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
2.80k
        size_type p = pos - begin();
337
2.80k
        difference_type count = last - first;
338
2.80k
        size_type new_size = size() + count;
339
2.80k
        if (capacity() < new_size) {
340
248
            change_capacity(new_size + (new_size >> 1));
341
248
        }
342
2.80k
        T* ptr = item_ptr(p);
343
2.80k
        T* dst = ptr + count;
344
2.80k
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
2.80k
        _size += count;
346
2.80k
        fill(ptr, first, last);
347
2.80k
    }
void prevector<36u, unsigned char, unsigned int, int>::insert<prevector<36u, unsigned char, unsigned int, int>::const_iterator>(prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator, prevector<36u, unsigned char, unsigned int, int>::const_iterator)
Line
Count
Source
335
2.77M
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
2.77M
        size_type p = pos - begin();
337
2.77M
        difference_type count = last - first;
338
2.77M
        size_type new_size = size() + count;
339
2.77M
        if (capacity() < new_size) {
340
128k
            change_capacity(new_size + (new_size >> 1));
341
128k
        }
342
2.77M
        T* ptr = item_ptr(p);
343
2.77M
        T* dst = ptr + count;
344
2.77M
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
2.77M
        _size += count;
346
2.77M
        fill(ptr, first, last);
347
2.77M
    }
void prevector<35u, unsigned char, unsigned int, int>::insert<unsigned char*>(prevector<35u, unsigned char, unsigned int, int>::iterator, unsigned char*, unsigned char*)
Line
Count
Source
335
298
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
298
        size_type p = pos - begin();
337
298
        difference_type count = last - first;
338
298
        size_type new_size = size() + count;
339
298
        if (capacity() < new_size) {
340
0
            change_capacity(new_size + (new_size >> 1));
341
0
        }
342
298
        T* ptr = item_ptr(p);
343
298
        T* dst = ptr + count;
344
298
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
298
        _size += count;
346
298
        fill(ptr, first, last);
347
298
    }
void prevector<35u, unsigned char, unsigned int, int>::insert<unsigned char const*>(prevector<35u, unsigned char, unsigned int, int>::iterator, unsigned char const*, unsigned char const*)
Line
Count
Source
335
298
    void insert(iterator pos, InputIterator first, InputIterator last) {
336
298
        size_type p = pos - begin();
337
298
        difference_type count = last - first;
338
298
        size_type new_size = size() + count;
339
298
        if (capacity() < new_size) {
340
0
            change_capacity(new_size + (new_size >> 1));
341
0
        }
342
298
        T* ptr = item_ptr(p);
343
298
        T* dst = ptr + count;
344
298
        memmove(dst, ptr, (size() - p) * sizeof(T));
345
298
        _size += count;
346
298
        fill(ptr, first, last);
347
298
    }
348
349
1.07M
    inline void resize_uninitialized(size_type new_size) {
350
        // resize_uninitialized changes the size of the prevector but does not initialize it.
351
        // If size < new_size, the added elements must be initialized explicitly.
352
1.07M
        if (capacity() < new_size) {
353
234k
            change_capacity(new_size);
354
234k
            _size += new_size - size();
355
234k
            return;
356
234k
        }
357
844k
        if (new_size < size()) {
358
3.18k
            erase(item_ptr(new_size), end());
359
841k
        } else {
360
841k
            _size += new_size - size();
361
841k
        }
362
844k
    }
prevector<36u, unsigned char, unsigned int, int>::resize_uninitialized(unsigned int)
Line
Count
Source
349
1.07M
    inline void resize_uninitialized(size_type new_size) {
350
        // resize_uninitialized changes the size of the prevector but does not initialize it.
351
        // If size < new_size, the added elements must be initialized explicitly.
352
1.07M
        if (capacity() < new_size) {
353
233k
            change_capacity(new_size);
354
233k
            _size += new_size - size();
355
233k
            return;
356
233k
        }
357
837k
        if (new_size < size()) {
358
0
            erase(item_ptr(new_size), end());
359
837k
        } else {
360
837k
            _size += new_size - size();
361
837k
        }
362
837k
    }
prevector<8u, int, unsigned int, int>::resize_uninitialized(unsigned int)
Line
Count
Source
349
8.18k
    inline void resize_uninitialized(size_type new_size) {
350
        // resize_uninitialized changes the size of the prevector but does not initialize it.
351
        // If size < new_size, the added elements must be initialized explicitly.
352
8.18k
        if (capacity() < new_size) {
353
1.23k
            change_capacity(new_size);
354
1.23k
            _size += new_size - size();
355
1.23k
            return;
356
1.23k
        }
357
6.94k
        if (new_size < size()) {
358
3.18k
            erase(item_ptr(new_size), end());
359
3.76k
        } else {
360
3.76k
            _size += new_size - size();
361
3.76k
        }
362
6.94k
    }
363
364
27.4k
    iterator erase(iterator pos) {
365
27.4k
        return erase(pos, pos + 1);
366
27.4k
    }
367
368
11.9M
    iterator erase(iterator first, iterator last) {
369
        // Erase is not allowed to the change the object's capacity. That means
370
        // that when starting with an indirectly allocated prevector with
371
        // size and capacity > N, the result may be a still indirectly allocated
372
        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
373
        // necessary to switch to the (more efficient) directly allocated
374
        // representation (with capacity N and size <= N).
375
11.9M
        iterator p = first;
376
11.9M
        char* endp = (char*)&(*end());
377
11.9M
        _size -= last - p;
378
11.9M
        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
379
11.9M
        return first;
380
11.9M
    }
prevector<36u, unsigned char, unsigned int, int>::erase(prevector<36u, unsigned char, unsigned int, int>::iterator, prevector<36u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
368
11.6M
    iterator erase(iterator first, iterator last) {
369
        // Erase is not allowed to the change the object's capacity. That means
370
        // that when starting with an indirectly allocated prevector with
371
        // size and capacity > N, the result may be a still indirectly allocated
372
        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
373
        // necessary to switch to the (more efficient) directly allocated
374
        // representation (with capacity N and size <= N).
375
11.6M
        iterator p = first;
376
11.6M
        char* endp = (char*)&(*end());
377
11.6M
        _size -= last - p;
378
11.6M
        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
379
11.6M
        return first;
380
11.6M
    }
prevector<16u, unsigned char, unsigned int, int>::erase(prevector<16u, unsigned char, unsigned int, int>::iterator, prevector<16u, unsigned char, unsigned int, int>::iterator)
Line
Count
Source
368
165k
    iterator erase(iterator first, iterator last) {
369
        // Erase is not allowed to the change the object's capacity. That means
370
        // that when starting with an indirectly allocated prevector with
371
        // size and capacity > N, the result may be a still indirectly allocated
372
        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
373
        // necessary to switch to the (more efficient) directly allocated
374
        // representation (with capacity N and size <= N).
375
165k
        iterator p = first;
376
165k
        char* endp = (char*)&(*end());
377
165k
        _size -= last - p;
378
165k
        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
379
165k
        return first;
380
165k
    }
prevector<8u, int, unsigned int, int>::erase(prevector<8u, int, unsigned int, int>::iterator, prevector<8u, int, unsigned int, int>::iterator)
Line
Count
Source
368
70.1k
    iterator erase(iterator first, iterator last) {
369
        // Erase is not allowed to the change the object's capacity. That means
370
        // that when starting with an indirectly allocated prevector with
371
        // size and capacity > N, the result may be a still indirectly allocated
372
        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
373
        // necessary to switch to the (more efficient) directly allocated
374
        // representation (with capacity N and size <= N).
375
70.1k
        iterator p = first;
376
70.1k
        char* endp = (char*)&(*end());
377
70.1k
        _size -= last - p;
378
70.1k
        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
379
70.1k
        return first;
380
70.1k
    }
Unexecuted instantiation: prevector<33u, unsigned char, unsigned int, int>::erase(prevector<33u, unsigned char, unsigned int, int>::iterator, prevector<33u, unsigned char, unsigned int, int>::iterator)
381
382
    template<typename... Args>
383
82.6k
    void emplace_back(Args&&... args) {
384
82.6k
        size_type new_size = size() + 1;
385
82.6k
        if (capacity() < new_size) {
386
13.2k
            change_capacity(new_size + (new_size >> 1));
387
13.2k
        }
388
82.6k
        new(item_ptr(size())) T(std::forward<Args>(args)...);
389
82.6k
        _size++;
390
82.6k
    }
void prevector<36u, unsigned char, unsigned int, int>::emplace_back<unsigned char const&>(unsigned char const&)
Line
Count
Source
383
73.7k
    void emplace_back(Args&&... args) {
384
73.7k
        size_type new_size = size() + 1;
385
73.7k
        if (capacity() < new_size) {
386
13.0k
            change_capacity(new_size + (new_size >> 1));
387
13.0k
        }
388
73.7k
        new(item_ptr(size())) T(std::forward<Args>(args)...);
389
73.7k
        _size++;
390
73.7k
    }
void prevector<8u, int, unsigned int, int>::emplace_back<int const&>(int const&)
Line
Count
Source
383
8.16k
    void emplace_back(Args&&... args) {
384
8.16k
        size_type new_size = size() + 1;
385
8.16k
        if (capacity() < new_size) {
386
214
            change_capacity(new_size + (new_size >> 1));
387
214
        }
388
8.16k
        new(item_ptr(size())) T(std::forward<Args>(args)...);
389
8.16k
        _size++;
390
8.16k
    }
void prevector<4u, Network, unsigned int, int>::emplace_back<Network const&>(Network const&)
Line
Count
Source
383
780
    void emplace_back(Args&&... args) {
384
780
        size_type new_size = size() + 1;
385
780
        if (capacity() < new_size) {
386
0
            change_capacity(new_size + (new_size >> 1));
387
0
        }
388
780
        new(item_ptr(size())) T(std::forward<Args>(args)...);
389
780
        _size++;
390
780
    }
391
392
82.6k
    void push_back(const T& value) {
393
82.6k
        emplace_back(value);
394
82.6k
    }
prevector<36u, unsigned char, unsigned int, int>::push_back(unsigned char const&)
Line
Count
Source
392
73.7k
    void push_back(const T& value) {
393
73.7k
        emplace_back(value);
394
73.7k
    }
prevector<8u, int, unsigned int, int>::push_back(int const&)
Line
Count
Source
392
8.16k
    void push_back(const T& value) {
393
8.16k
        emplace_back(value);
394
8.16k
    }
prevector<4u, Network, unsigned int, int>::push_back(Network const&)
Line
Count
Source
392
780
    void push_back(const T& value) {
393
780
        emplace_back(value);
394
780
    }
395
396
6.95k
    void pop_back() {
397
6.95k
        erase(end() - 1, end());
398
6.95k
    }
399
400
    T& front() {
401
        return *item_ptr(0);
402
    }
403
404
    const T& front() const {
405
        return *item_ptr(0);
406
    }
407
408
    T& back() {
409
        return *item_ptr(size() - 1);
410
    }
411
412
28.2k
    const T& back() const {
413
28.2k
        return *item_ptr(size() - 1);
414
28.2k
    }
415
416
    void swap(prevector<N, T, Size, Diff>& other) noexcept
417
16.2k
    {
418
16.2k
        std::swap(_union, other._union);
419
16.2k
        std::swap(_size, other._size);
420
16.2k
    }
421
422
152M
    ~prevector() {
423
152M
        if (!is_direct()) {
424
2.29M
            free(_union.indirect_contents.indirect);
425
2.29M
            _union.indirect_contents.indirect = nullptr;
426
2.29M
        }
427
152M
    }
prevector<16u, unsigned char, unsigned int, int>::~prevector()
Line
Count
Source
422
1.52M
    ~prevector() {
423
1.52M
        if (!is_direct()) {
424
2.57k
            free(_union.indirect_contents.indirect);
425
2.57k
            _union.indirect_contents.indirect = nullptr;
426
2.57k
        }
427
1.52M
    }
prevector<36u, unsigned char, unsigned int, int>::~prevector()
Line
Count
Source
422
149M
    ~prevector() {
423
149M
        if (!is_direct()) {
424
2.09M
            free(_union.indirect_contents.indirect);
425
2.09M
            _union.indirect_contents.indirect = nullptr;
426
2.09M
        }
427
149M
    }
prevector<33u, unsigned char, unsigned int, int>::~prevector()
Line
Count
Source
422
638k
    ~prevector() {
423
638k
        if (!is_direct()) {
424
0
            free(_union.indirect_contents.indirect);
425
0
            _union.indirect_contents.indirect = nullptr;
426
0
        }
427
638k
    }
prevector<8u, int, unsigned int, int>::~prevector()
Line
Count
Source
422
531k
    ~prevector() {
423
531k
        if (!is_direct()) {
424
194k
            free(_union.indirect_contents.indirect);
425
194k
            _union.indirect_contents.indirect = nullptr;
426
194k
        }
427
531k
    }
prevector<4u, Network, unsigned int, int>::~prevector()
Line
Count
Source
422
394
    ~prevector() {
423
394
        if (!is_direct()) {
424
0
            free(_union.indirect_contents.indirect);
425
0
            _union.indirect_contents.indirect = nullptr;
426
0
        }
427
394
    }
prevector<35u, unsigned char, unsigned int, int>::~prevector()
Line
Count
Source
422
298
    ~prevector() {
423
298
        if (!is_direct()) {
424
0
            free(_union.indirect_contents.indirect);
425
0
            _union.indirect_contents.indirect = nullptr;
426
0
        }
427
298
    }
428
429
7.22M
    constexpr bool operator==(const prevector& other) const {
430
7.22M
        return std::ranges::equal(*this, other);
431
7.22M
    }
prevector<36u, unsigned char, unsigned int, int>::operator==(prevector<36u, unsigned char, unsigned int, int> const&) const
Line
Count
Source
429
6.47M
    constexpr bool operator==(const prevector& other) const {
430
6.47M
        return std::ranges::equal(*this, other);
431
6.47M
    }
prevector<8u, int, unsigned int, int>::operator==(prevector<8u, int, unsigned int, int> const&) const
Line
Count
Source
429
531k
    constexpr bool operator==(const prevector& other) const {
430
531k
        return std::ranges::equal(*this, other);
431
531k
    }
prevector<16u, unsigned char, unsigned int, int>::operator==(prevector<16u, unsigned char, unsigned int, int> const&) const
Line
Count
Source
429
215k
    constexpr bool operator==(const prevector& other) const {
430
215k
        return std::ranges::equal(*this, other);
431
215k
    }
432
433
22.9M
    bool operator<(const prevector<N, T, Size, Diff>& other) const {
434
22.9M
        if (size() < other.size()) {
435
948k
            return true;
436
948k
        }
437
21.9M
        if (size() > other.size()) {
438
324k
            return false;
439
324k
        }
440
21.6M
        const_iterator b1 = begin();
441
21.6M
        const_iterator b2 = other.begin();
442
21.6M
        const_iterator e1 = end();
443
133M
        while (b1 != e1) {
444
130M
            if ((*b1) < (*b2)) {
445
10.9M
                return true;
446
10.9M
            }
447
119M
            if ((*b2) < (*b1)) {
448
8.17M
                return false;
449
8.17M
            }
450
111M
            ++b1;
451
111M
            ++b2;
452
111M
        }
453
2.51M
        return false;
454
21.6M
    }
prevector<36u, unsigned char, unsigned int, int>::operator<(prevector<36u, unsigned char, unsigned int, int> const&) const
Line
Count
Source
433
22.8M
    bool operator<(const prevector<N, T, Size, Diff>& other) const {
434
22.8M
        if (size() < other.size()) {
435
948k
            return true;
436
948k
        }
437
21.9M
        if (size() > other.size()) {
438
324k
            return false;
439
324k
        }
440
21.6M
        const_iterator b1 = begin();
441
21.6M
        const_iterator b2 = other.begin();
442
21.6M
        const_iterator e1 = end();
443
133M
        while (b1 != e1) {
444
130M
            if ((*b1) < (*b2)) {
445
10.9M
                return true;
446
10.9M
            }
447
119M
            if ((*b2) < (*b1)) {
448
8.17M
                return false;
449
8.17M
            }
450
111M
            ++b1;
451
111M
            ++b2;
452
111M
        }
453
2.49M
        return false;
454
21.6M
    }
prevector<16u, unsigned char, unsigned int, int>::operator<(prevector<16u, unsigned char, unsigned int, int> const&) const
Line
Count
Source
433
21.6k
    bool operator<(const prevector<N, T, Size, Diff>& other) const {
434
21.6k
        if (size() < other.size()) {
435
0
            return true;
436
0
        }
437
21.6k
        if (size() > other.size()) {
438
0
            return false;
439
0
        }
440
21.6k
        const_iterator b1 = begin();
441
21.6k
        const_iterator b2 = other.begin();
442
21.6k
        const_iterator e1 = end();
443
109k
        while (b1 != e1) {
444
87.9k
            if ((*b1) < (*b2)) {
445
308
                return true;
446
308
            }
447
87.6k
            if ((*b2) < (*b1)) {
448
117
                return false;
449
117
            }
450
87.5k
            ++b1;
451
87.5k
            ++b2;
452
87.5k
        }
453
21.2k
        return false;
454
21.6k
    }
455
456
46.1M
    size_t allocated_memory() const {
457
46.1M
        if (is_direct()) {
458
45.2M
            return 0;
459
45.2M
        } else {
460
929k
            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
461
929k
        }
462
46.1M
    }
463
464
611k
    value_type* data() {
465
611k
        return item_ptr(0);
466
611k
    }
prevector<16u, unsigned char, unsigned int, int>::data()
Line
Count
Source
464
42.1k
    value_type* data() {
465
42.1k
        return item_ptr(0);
466
42.1k
    }
prevector<33u, unsigned char, unsigned int, int>::data()
Line
Count
Source
464
262k
    value_type* data() {
465
262k
        return item_ptr(0);
466
262k
    }
prevector<36u, unsigned char, unsigned int, int>::data()
Line
Count
Source
464
306k
    value_type* data() {
465
306k
        return item_ptr(0);
466
306k
    }
prevector<35u, unsigned char, unsigned int, int>::data()
Line
Count
Source
464
298
    value_type* data() {
465
298
        return item_ptr(0);
466
298
    }
467
468
35.1M
    const value_type* data() const {
469
35.1M
        return item_ptr(0);
470
35.1M
    }
prevector<16u, unsigned char, unsigned int, int>::data() const
Line
Count
Source
468
2.28M
    const value_type* data() const {
469
2.28M
        return item_ptr(0);
470
2.28M
    }
prevector<36u, unsigned char, unsigned int, int>::data() const
Line
Count
Source
468
32.7M
    const value_type* data() const {
469
32.7M
        return item_ptr(0);
470
32.7M
    }
prevector<33u, unsigned char, unsigned int, int>::data() const
Line
Count
Source
468
133k
    const value_type* data() const {
469
133k
        return item_ptr(0);
470
133k
    }
471
};
472
473
#endif // BITCOIN_PREVECTOR_H