GCC Code Coverage Report

Directory: ./
File: IndirectSequence.hpp
Date: 2026-03-21 20:51:59
Exec Total Coverage
Lines: 18 18 100.0%
Functions: 11 13 84.6%
Branches: 2 4 50.0%
Line Branch Exec Source
1 #pragma once
2
3 #include <boost/iterator/indirect_iterator.hpp>
4
5 template <typename S>
6 class IndirectSequence {
7 public:
8 using value_type =
9 typename std::pointer_traits<typename S::value_type>::element_type;
10 using size_type = typename S::size_type;
11 using difference_type = typename S::difference_type;
12 using reference = value_type&;
13 using const_reference = const value_type&;
14 using iterator = boost::indirect_iterator<typename S::iterator>;
15 using const_iterator = boost::indirect_iterator<typename S::const_iterator>;
16 using reverse_iterator =
17 boost::indirect_iterator<typename S::reverse_iterator>;
18 using const_reverse_iterator =
19 boost::indirect_iterator<typename S::const_reverse_iterator>;
20
21 S base{};
22 bool operator==(const IndirectSequence& other) const noexcept;
23 bool operator<(const IndirectSequence& other) const noexcept;
24
25 reference at(size_type pos);
26 [[nodiscard]] const_reference at(size_type pos) const;
27
28 reference operator[](size_type pos);
29 const_reference operator[](size_type pos) const;
30
31 reference front();
32 [[nodiscard]] const_reference front() const;
33
34 reference back();
35 [[nodiscard]] const_reference back() const;
36
37 iterator begin();
38 [[nodiscard]] const_iterator begin() const;
39 [[nodiscard]] const_iterator cbegin() const noexcept;
40
41 iterator end() noexcept;
42 [[nodiscard]] const_iterator end() const noexcept;
43 [[nodiscard]] const_iterator cend() const noexcept;
44
45 reverse_iterator rbegin();
46 [[nodiscard]] const_reverse_iterator rbegin() const;
47 [[nodiscard]] const_reverse_iterator crbegin() const noexcept;
48
49 reverse_iterator rend();
50 [[nodiscard]] const_reverse_iterator rend() const;
51 [[nodiscard]] const_reverse_iterator crend() const noexcept;
52
53 [[nodiscard]] bool empty() const;
54 [[nodiscard]] size_type size() const;
55 void clear();
56 };
57
58 ////////////////////////////////////////////////////////////////////////////////
59
60 template <typename S>
61 1 auto IndirectSequence<S>::operator==(const IndirectSequence& other) const noexcept
62 -> bool {
63 1 return base == other.base;
64 }
65
66 template <typename S>
67 auto IndirectSequence<S>::operator<(const IndirectSequence& other) const noexcept
68 -> bool {
69 return base < other.base;
70 }
71
72 template <typename S>
73 auto IndirectSequence<S>::at(size_type pos) -> reference {
74 return *base.at(pos);
75 }
76
77 template <typename S>
78 auto IndirectSequence<S>::at(size_type pos) const -> const_reference {
79 return *base.at(pos);
80 }
81
82 template <typename S>
83 26 auto IndirectSequence<S>::operator[](size_type pos) -> reference {
84 26 return *base[pos];
85 }
86
87 template <typename S>
88 auto IndirectSequence<S>::operator[](size_type pos) const -> const_reference {
89 return *base[pos];
90 }
91
92 template <typename S>
93 1 auto IndirectSequence<S>::front() -> reference {
94 1 return *base.front();
95 }
96
97 template <typename S>
98 auto IndirectSequence<S>::front() const -> const_reference {
99 return *base.front();
100 }
101
102 template <typename S>
103 1 auto IndirectSequence<S>::back() -> reference {
104 1 return *base.back();
105 }
106
107 template <typename S>
108 auto IndirectSequence<S>::back() const -> const_reference {
109 return *base.back();
110 }
111
112 template <typename S>
113 5 auto IndirectSequence<S>::begin() -> iterator {
114
1/2
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
 10 return base.begin();
115 }
116
117 template <typename S>
118 10 auto IndirectSequence<S>::begin() const -> const_iterator {
119
1/2
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
 20 return base.begin();
120 }
121
122 template <typename S>
123 auto IndirectSequence<S>::cbegin() const noexcept -> const_iterator {
124 return base.cbegin();
125 }
126
127 template <typename S>
128 5 auto IndirectSequence<S>::end() noexcept -> iterator {
129 5 return base.end();
130 }
131
132 template <typename S>
133 10 auto IndirectSequence<S>::end() const noexcept -> const_iterator {
134 10 return base.end();
135 }
136
137 template <typename S>
138 auto IndirectSequence<S>::cend() const noexcept -> const_iterator {
139 return base.cend();
140 }
141
142 template <typename S>
143 auto IndirectSequence<S>::rbegin() -> reverse_iterator {
144 return base.rbegin();
145 }
146
147 template <typename S>
148 auto IndirectSequence<S>::rbegin() const -> const_reverse_iterator {
149 return base.rbegin();
150 }
151
152 template <typename S>
153 auto IndirectSequence<S>::crbegin() const noexcept -> const_reverse_iterator {
154 return base.crbegin();
155 }
156
157 template <typename S>
158 auto IndirectSequence<S>::rend() -> reverse_iterator {
159 return base.rend();
160 }
161
162 template <typename S>
163 auto IndirectSequence<S>::rend() const -> const_reverse_iterator {
164 return base.rend();
165 }
166
167 template <typename S>
168 auto IndirectSequence<S>::crend() const noexcept -> const_reverse_iterator {
169 return base.crend();
170 }
171
172 template <typename S>
173 auto IndirectSequence<S>::empty() const -> bool {
174 return base.empty();
175 }
176
177 template <typename S>
178 16 auto IndirectSequence<S>::size() const -> size_type {
179 16 return base.size();
180 }
181
182 template <typename S>
183 void IndirectSequence<S>::clear() {
184 base.clear();
185 }
186