14987214130

Committed 13 May 2025 03:02AM UTC coverage: 49.385% (-46.9%) from 96.333%

Build # 14987214130

Build Type

Pull #7

github

Committed by

web-flow

Commit Message

Merge aad228108 into 09dd4e61e

Pull Request Pull Request #7: Add github workflow targets for warnings

Run Details

5155 of 10638 branches covered (48.46%)

Branch coverage included in aggregate %.

39 of 70 new or added lines in 1 file covered. (55.71%)

128 existing lines in 10 files now uncovered.

5325 of 10583 relevant lines covered (50.32%)

3238286.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.06

/include/bitlib/bit-iterator/bit_iterator.hpp

// ============================== BIT ITERATOR ============================== //
// Project:         The C++ Bit Library
// Name:            bit_iterator.hpp
// Description:     A class representing an iterator on bit sequences
// Creator:         Vincent Reverdy
// Contributor(s):  Vincent Reverdy [2015-2017]
// License:         BSD 3-Clause License
// ========================================================================== //
#ifndef _BIT_ITERATOR_HPP_INCLUDED
#define _BIT_ITERATOR_HPP_INCLUDED
// ========================================================================== //



// ================================ PREAMBLE ================================ //
// C++ standard library
#include <compare>
#include <concepts>
#include <cstddef>
#include <iterator>
#include <type_traits>

#include "bitlib/bit-containers/bit_bitsof.hpp"
#include "bitlib/bit_concepts.hpp"
// Project sources
#include "bit_details.hpp"
#include "bit_reference.hpp"
// Third-party libraries
// Miscellaneous
namespace bit {

/* ****************************** BIT ITERATOR ****************************** */
// Bit iterator class definition
template <class Iterator>
class bit_iterator
{
  template <class>
  friend class bit_iterator;

  // Assertions
 private:
  using _traits_t = _cv_iterator_traits<Iterator>;
  static_assert(binary_digits<typename _traits_t::value_type>::value, "");

  // Types
 public:
  using iterator_type = Iterator;
  using word_type = typename _traits_t::value_type;
  using iterator_category = typename _traits_t::iterator_category;
  using value_type = bit_value;
  using difference_type = std::ptrdiff_t;
  using pointer = bit_pointer<word_type>;
  using reference = bit_reference<word_type>;
  using size_type = std::size_t;
  using mask_type = std::make_unsigned_t<std::remove_cv_t<word_type>>;

  // Lifecycle
 public:
  constexpr bit_iterator();
  template <class T>
  constexpr bit_iterator(const bit_iterator<T>& other)
    requires std::constructible_from<iterator_type, T>;
  explicit constexpr bit_iterator(iterator_type i);
  constexpr bit_iterator(iterator_type i, size_type pos);
  explicit constexpr bit_iterator(const pointer& ptr)
    requires std::constructible_from<iterator_type, word_type*>;

  // Assignment
 public:
  template <class T>
  constexpr bit_iterator& operator=(const bit_iterator<T>& other);

  // Access
 public:
  constexpr reference operator*() const noexcept;
  constexpr pointer operator->() const noexcept;
  constexpr reference operator[](difference_type n) const;

  // Increment and decrement operators
 public:
  constexpr bit_iterator& operator++();
  constexpr bit_iterator& operator--();
  constexpr bit_iterator operator++(int);
  constexpr bit_iterator operator--(int);
  constexpr bit_iterator operator+(difference_type n) const;
  constexpr bit_iterator operator-(difference_type n) const;
  constexpr bit_iterator& operator+=(difference_type n);
  constexpr bit_iterator& operator-=(difference_type n);
  constexpr difference_type operator-(const bit_iterator&) const;

  // Underlying details
 public:
  constexpr iterator_type base() const;
  constexpr iterator_type address() const;
  constexpr size_type position() const noexcept;

  auto operator<=>(const bit_iterator&) const = default;
  // Implementation details: data members
 private:
  iterator_type _current;
  size_type _position;

  // Non-member arithmetic operators
  template <class T>
  friend constexpr bit_iterator<T> operator+(
      typename bit_iterator<T>::difference_type n,
      const bit_iterator<T>& i);
  template <class T, class U>
  friend constexpr typename std::common_type<
      typename bit_iterator<T>::difference_type,
      typename bit_iterator<U>::difference_type>::type
  operator-(
      const bit_iterator<T>& lhs,
      const bit_iterator<U>& rhs);
};
/* ************************************************************************** */



// ------------------------ BIT ITERATOR: LIFECYCLE ------------------------- //
// Implicitly default constructs a bit iterator
template <class Iterator>
constexpr bit_iterator<Iterator>::bit_iterator()
    : _current(), _position() {
}

// Implicitly constructs a bit iterator from another bit iterator
template <class Iterator>
template <class T>
constexpr bit_iterator<Iterator>::bit_iterator(const bit_iterator<T>& other)
  requires std::constructible_from<iterator_type, T>
    : _current(other.base()), _position(other.position()) {
  assert(_position < bitsof<word_type>());
}

// Explicitly constructs an aligned bit iterator from an iterator
template <class Iterator>
constexpr bit_iterator<Iterator>::bit_iterator(const iterator_type i)
    : _current(i), _position(0) {
}

// Explicitly constructs an unaligned bit iterator from an iterator
template <class Iterator>
constexpr bit_iterator<Iterator>::bit_iterator(const iterator_type i, size_type pos)
    : _current(i), _position((assert(pos < binary_digits<word_type>::value), pos)) {
}

// Explicitly constructs an unaligned bit iterator from a pointer
template <class Iterator>
constexpr bit_iterator<Iterator>::bit_iterator(const pointer& ptr)
  requires std::constructible_from<iterator_type, word_type*>
    : _current(ptr._current), _position(ptr.position()) {
  assert(_position < bitsof<word_type>());
}
// -------------------------------------------------------------------------- //



// ------------------------ BIT ITERATOR: ASSIGNMENT ------------------------ //
// Assigns a bit iterator to the bit iterator
template <class Iterator>
template <class T>
constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator=(
    const bit_iterator<T>& other) {
  _current = other._current;
  _position = other._position;
  assert(_position < bitsof<word_type>());
  return *this;
}
// -------------------------------------------------------------------------- //



// -------------------------- BIT ITERATOR: ACCESS -------------------------- //
// Gets a bit reference from the bit iterator
template <class Iterator>
constexpr typename bit_iterator<Iterator>::reference
bit_iterator<Iterator>::operator*() const noexcept {
  return reference(*_current, _position);
}

// Gets a pointer to a bit
template <class Iterator>
constexpr typename bit_iterator<Iterator>::pointer bit_iterator<Iterator>::operator->() const noexcept {
  return pointer(&*_current, _position);
}

// Gets a bit reference, decrementing or incrementing the iterator
template <class Iterator>
constexpr typename bit_iterator<Iterator>::reference bit_iterator<Iterator>::operator[](difference_type n) const {
  constexpr difference_type digits = binary_digits<word_type>::value;
  const difference_type sum = _position + n;
  difference_type diff = sum / digits;
  if (sum < 0 && diff * digits != sum) {
    --diff;
  }
  return reference(*std::next(_current, diff), sum - diff * digits);
}
// -------------------------------------------------------------------------- //



// ------------- BIT ITERATOR: INCREMENT AND DECREMENT OPERATORS ------------ //
// Increments the bit iterator and returns it
template <class Iterator>
constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator++() {
  constexpr size_type digits = binary_digits<word_type>::value;
  if (_position + 1 < digits) {
    ++_position;
  } else {
    ++_current;
    _position = 0;
  }
  return *this;
}

// Decrements the bit iterator and returns it
template <class Iterator>
constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator--() {
  constexpr size_type digits = binary_digits<word_type>::value;
  if (_position) {
    --_position;
  } else {
    --_current;
    _position = digits - 1;
  }
  return *this;
}

// Increments the bit iterator and returns the old one
template <class Iterator>
constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator++(int) {
  bit_iterator old = *this;
  ++(*this);
  return old;
}

// Decrements the bit iterator and returns the old one
template <class Iterator>
constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator--(int) {
  bit_iterator old = *this;
  --(*this);
  return old;
}

// Looks forward several bits and gets an iterator at this position
template <class Iterator>
constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator+(difference_type n) const {
  constexpr difference_type digits = binary_digits<word_type>::value;
  const difference_type sum = _position + n;
  difference_type diff = sum / digits;
  if (sum < 0 && diff * digits != sum) {
    --diff;
  }
  return bit_iterator(std::next(_current, diff), sum - diff * digits);
}

// Looks backward several bits and gets an iterator at this position
template <class Iterator>
constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator-(difference_type n) const {
  constexpr difference_type digits = binary_digits<word_type>::value;
  const difference_type sum = _position - n;
  difference_type diff = sum / digits;
  if (sum < 0 && diff * digits != sum) {
    --diff;
  }
  return bit_iterator(std::next(_current, diff), sum - diff * digits);
}

// Increments the iterator by several bits and returns it
template <class Iterator>
constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator+=(difference_type n) {
  constexpr difference_type digits = binary_digits<word_type>::value;
  const difference_type sum = _position + n;
  difference_type diff = sum / digits;
  if (sum < 0 && diff * digits != sum) {
    --diff;
  }
  _current = std::next(_current, diff);
  _position = (sum - diff * digits);
  return *this;
}

// Decrements the iterator by several bits and returns it
template <class Iterator>
constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator-=(difference_type n) {
  constexpr difference_type digits = binary_digits<word_type>::value;
  const difference_type sum = _position - n;
  difference_type diff = sum / digits;
  if (sum < 0 && diff * digits != sum) {
    --diff;
  }
  _current = std::next(_current, diff);
  _position = (sum - diff * digits);
  return *this;
}
// -------------------------------------------------------------------------- //

template <class Iterator>
constexpr bit_iterator<Iterator>::difference_type
bit_iterator<Iterator>::operator-(const bit_iterator<Iterator>& other) const {
  constexpr difference_type digits = binary_digits<word_type>::value;
  return (_current - other._current) * digits + (_position - other._position);
}

// -------------------- BIT ITERATOR: UNDERLYING DETAILS -------------------- //
// Returns a copy of the underlying iterator
template <class Iterator>
constexpr typename bit_iterator<Iterator>::iterator_type bit_iterator<Iterator>::base() const {
  return _current;
}

template <class Iterator>
constexpr typename bit_iterator<Iterator>::iterator_type bit_iterator<Iterator>::address() const {
  return _current;
}

// Returns the position of the bit within the underlying word
template <class Iterator>
constexpr typename bit_iterator<Iterator>::size_type bit_iterator<Iterator>::position() const noexcept {
  return _position;
}

// -------------- BIT ITERATOR: NON-MEMBER ARITHMETIC OPERATORS ------------- //
// Advances the bit iterator several times
template <class T>
constexpr bit_iterator<T> operator+(typename bit_iterator<T>::difference_type n, const bit_iterator<T>& i) {
  return i + n;
}

// Computes the distance in bits separating two bit iterators
template <class T, class U>
constexpr typename std::common_type<
    typename bit_iterator<T>::difference_type,
    typename bit_iterator<U>::difference_type>::type
operator-(const bit_iterator<T>& lhs, const bit_iterator<U>& rhs) {
  using lhs_utype = typename bit_iterator<T>::word_type;
  using rhs_utype = typename bit_iterator<U>::word_type;
  using lhs_type = typename bit_iterator<T>::difference_type;
  using rhs_type = typename bit_iterator<U>::difference_type;
  using difference_type = typename std::common_type<lhs_type, rhs_type>::type;
  constexpr difference_type lhs_digits = binary_digits<lhs_utype>::value;
  constexpr difference_type rhs_digits = binary_digits<rhs_utype>::value;
  constexpr difference_type digits = rhs_digits;
  static_assert(lhs_digits == rhs_digits, "");
  const difference_type main = lhs._current - rhs._current;
  return main * digits + (lhs._position - rhs._position);
}

static_assert(bit_iterator_c<bit_iterator<uint8_t*>>, "bit_iterator does not satisfy bit_iterator_c concept!");
static_assert(bit_pointer_c<bit_pointer<uint8_t>, bit_reference<uint8_t>>, "bit_pointer does not satisfy bit_pointer_c concept!");
static_assert(bit_iterator_c<bit_pointer<uint8_t>>, "bit_pointer does not satisfy bit_iterator_c concept!");

// ========================================================================== //
} // namespace bit
#endif // _BIT_ITERATOR_HPP_INCLUDED
// ========================================================================== //

1	// ============================== BIT ITERATOR ============================== //
2	// Project: The C++ Bit Library
3	// Name: bit_iterator.hpp
4	// Description: A class representing an iterator on bit sequences
5	// Creator: Vincent Reverdy
6	// Contributor(s): Vincent Reverdy [2015-2017]
7	// License: BSD 3-Clause License
8	// ========================================================================== //
9	#ifndef _BIT_ITERATOR_HPP_INCLUDED
10	#define _BIT_ITERATOR_HPP_INCLUDED
11	// ========================================================================== //
12
13
14
15	// ================================ PREAMBLE ================================ //
16	// C++ standard library
17	#include <compare>
18	#include <concepts>
19	#include <cstddef>
20	#include <iterator>
21	#include <type_traits>
22
23	#include "bitlib/bit-containers/bit_bitsof.hpp"
24	#include "bitlib/bit_concepts.hpp"
25	// Project sources
26	#include "bit_details.hpp"
27	#include "bit_reference.hpp"
28	// Third-party libraries
29	// Miscellaneous
30	namespace bit {
31
32	/* **************************** BIT ITERATOR **************************** */
33	// Bit iterator class definition
34	template <class Iterator>
35	class bit_iterator
36	{
37	template <class>
38	friend class bit_iterator;
39
40	// Assertions
41	private:
42	using _traits_t = _cv_iterator_traits<Iterator>;
43	static_assert(binary_digits<typename _traits_t::value_type>::value, "");
44
45	// Types
46	public:
47	using iterator_type = Iterator;
48	using word_type = typename _traits_t::value_type;
49	using iterator_category = typename _traits_t::iterator_category;
50	using value_type = bit_value;
51	using difference_type = std::ptrdiff_t;
52	using pointer = bit_pointer<word_type>;
53	using reference = bit_reference<word_type>;
54	using size_type = std::size_t;
55	using mask_type = std::make_unsigned_t<std::remove_cv_t<word_type>>;
56
57	// Lifecycle
58	public:
59	constexpr bit_iterator();
60	template <class T>
61	constexpr bit_iterator(const bit_iterator<T>& other)
62	requires std::constructible_from<iterator_type, T>;
63	explicit constexpr bit_iterator(iterator_type i);
64	constexpr bit_iterator(iterator_type i, size_type pos);
65	explicit constexpr bit_iterator(const pointer& ptr)
66	requires std::constructible_from<iterator_type, word_type*>;
67
68	// Assignment
69	public:
70	template <class T>
71	constexpr bit_iterator& operator=(const bit_iterator<T>& other);
72
73	// Access
74	public:
75	constexpr reference operator*() const noexcept;
76	constexpr pointer operator->() const noexcept;
77	constexpr reference operator[](difference_type n) const;
78
79	// Increment and decrement operators
80	public:
81	constexpr bit_iterator& operator++();
82	constexpr bit_iterator& operator--();
83	constexpr bit_iterator operator++(int);
84	constexpr bit_iterator operator--(int);
85	constexpr bit_iterator operator+(difference_type n) const;
86	constexpr bit_iterator operator-(difference_type n) const;
87	constexpr bit_iterator& operator+=(difference_type n);
88	constexpr bit_iterator& operator-=(difference_type n);
89	constexpr difference_type operator-(const bit_iterator&) const;
90
91	// Underlying details
92	public:
93	constexpr iterator_type base() const;
94	constexpr iterator_type address() const;
95	constexpr size_type position() const noexcept;
96
97	auto operator<=>(const bit_iterator&) const = default;
98	// Implementation details: data members
99	private:
100	iterator_type _current;
101	size_type _position;
102
103	// Non-member arithmetic operators
104	template <class T>
105	friend constexpr bit_iterator<T> operator+(
106	typename bit_iterator<T>::difference_type n,
107	const bit_iterator<T>& i);
108	template <class T, class U>
109	friend constexpr typename std::common_type<
110	typename bit_iterator<T>::difference_type,
111	typename bit_iterator<U>::difference_type>::type
112	operator-(
113	const bit_iterator<T>& lhs,
114	const bit_iterator<U>& rhs);
115	};
116	/* ************************************************************************** */
117
118
119
120	// ------------------------ BIT ITERATOR: LIFECYCLE ------------------------- //
121	// Implicitly default constructs a bit iterator
122	template <class Iterator>
123	constexpr bit_iterator<Iterator>::bit_iterator()
124	: _current(), _position() {
125	}
126
127	// Implicitly constructs a bit iterator from another bit iterator
128	template <class Iterator>
129	template <class T>
130	constexpr bit_iterator<Iterator>::bit_iterator(const bit_iterator<T>& other)
131	requires std::constructible_from<iterator_type, T>
132	: _current(other.base()), _position(other.position()) {	26,481✔
133	assert(_position < bitsof<word_type>());	26,481!
134	}	26,481✔
135
136	// Explicitly constructs an aligned bit iterator from an iterator
137	template <class Iterator>
138	constexpr bit_iterator<Iterator>::bit_iterator(const iterator_type i)
139	: _current(i), _position(0) {	6,417,864✔
140	}	6,417,864✔
141
142	// Explicitly constructs an unaligned bit iterator from an iterator
143	template <class Iterator>
144	constexpr bit_iterator<Iterator>::bit_iterator(const iterator_type i, size_type pos)
145	: _current(i), _position((assert(pos < binary_digits<word_type>::value), pos)) {	888,328!
146	}	888,328✔
147
148	// Explicitly constructs an unaligned bit iterator from a pointer
149	template <class Iterator>
150	constexpr bit_iterator<Iterator>::bit_iterator(const pointer& ptr)
151	requires std::constructible_from<iterator_type, word_type*>
152	: _current(ptr._current), _position(ptr.position()) {	299✔
153	assert(_position < bitsof<word_type>());	299!
154	}	299✔
155	// -------------------------------------------------------------------------- //
156
157
158
159	// ------------------------ BIT ITERATOR: ASSIGNMENT ------------------------ //
160	// Assigns a bit iterator to the bit iterator
161	template <class Iterator>
162	template <class T>
163	constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator=(
164	const bit_iterator<T>& other) {
165	_current = other._current;
166	_position = other._position;
167	assert(_position < bitsof<word_type>());
168	return *this;
169	}
170	// -------------------------------------------------------------------------- //
171
172
173
174	// -------------------------- BIT ITERATOR: ACCESS -------------------------- //
175	// Gets a bit reference from the bit iterator
176	template <class Iterator>
177	constexpr typename bit_iterator<Iterator>::reference
178	bit_iterator<Iterator>::operator*() const noexcept {	1,073,355,703✔
179	return reference(*_current, _position);	1,073,355,703✔
180	}	1,073,355,703✔
181
182	// Gets a pointer to a bit
183	template <class Iterator>
184	constexpr typename bit_iterator<Iterator>::pointer bit_iterator<Iterator>::operator->() const noexcept {
185	return pointer(&*_current, _position);
186	}
187
188	// Gets a bit reference, decrementing or incrementing the iterator
189	template <class Iterator>
190	constexpr typename bit_iterator<Iterator>::reference bit_iterator<Iterator>::operator[](difference_type n) const {	5,622,475✔
191	constexpr difference_type digits = binary_digits<word_type>::value;	5,622,475✔
192	const difference_type sum = _position + n;	5,622,475✔
193	difference_type diff = sum / digits;	5,622,475✔
194	if (sum < 0 && diff * digits != sum) {	5,622,475!
195	--diff;	×
UNCOV 196	}	×
197	return reference(std::next(_current, diff), sum - diff digits);	5,622,475✔
198	}	5,622,475✔
199	// -------------------------------------------------------------------------- //
200
201
202
203	// ------------- BIT ITERATOR: INCREMENT AND DECREMENT OPERATORS ------------ //
204	// Increments the bit iterator and returns it
205	template <class Iterator>
206	constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator++() {	1,073,355,648✔
207	constexpr size_type digits = binary_digits<word_type>::value;	1,073,355,648✔
208	if (_position + 1 < digits) {	1,073,355,648✔
209	++_position;	1,036,383,186✔
210	} else {	1,036,383,186✔
211	++_current;	36,972,462✔
212	_position = 0;	36,972,462✔
213	}	36,972,462✔
214	return *this;	1,073,355,648✔
215	}	1,073,355,648✔
216
217	// Decrements the bit iterator and returns it
218	template <class Iterator>
219	constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator--() {
220	constexpr size_type digits = binary_digits<word_type>::value;
221	if (_position) {
222	--_position;
223	} else {
224	--_current;
225	_position = digits - 1;
226	}
227	return *this;
228	}
229
230	// Increments the bit iterator and returns the old one
231	template <class Iterator>
232	constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator++(int) {	380✔
233	bit_iterator old = *this;	380✔
234	++(*this);	380✔
235	return old;	380✔
236	}	380✔
237
238	// Decrements the bit iterator and returns the old one
239	template <class Iterator>
240	constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator--(int) {
241	bit_iterator old = *this;
242	--(*this);
243	return old;
244	}
245
246	// Looks forward several bits and gets an iterator at this position
247	template <class Iterator>
248	constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator+(difference_type n) const {	521,168✔
249	constexpr difference_type digits = binary_digits<word_type>::value;	521,168✔
250	const difference_type sum = _position + n;	521,168✔
251	difference_type diff = sum / digits;	521,168✔
252	if (sum < 0 && diff * digits != sum) {	521,168!
253	--diff;	×
UNCOV 254	}	×
255	return bit_iterator(std::next(_current, diff), sum - diff * digits);	521,168✔
256	}	521,168✔
257
258	// Looks backward several bits and gets an iterator at this position
259	template <class Iterator>
260	constexpr bit_iterator<Iterator> bit_iterator<Iterator>::operator-(difference_type n) const {	296,430✔
261	constexpr difference_type digits = binary_digits<word_type>::value;	296,430✔
262	const difference_type sum = _position - n;	296,430✔
263	difference_type diff = sum / digits;	296,430✔
264	if (sum < 0 && diff * digits != sum) {	296,430✔
265	--diff;	244,678✔
266	}	244,678✔
267	return bit_iterator(std::next(_current, diff), sum - diff * digits);	296,430✔
268	}	296,430✔
269
270	// Increments the iterator by several bits and returns it
271	template <class Iterator>
272	constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator+=(difference_type n) {	463,858✔
273	constexpr difference_type digits = binary_digits<word_type>::value;	463,858✔
274	const difference_type sum = _position + n;	463,858✔
275	difference_type diff = sum / digits;	463,858✔
276	if (sum < 0 && diff * digits != sum) {	463,858!
277	--diff;	197,105✔
278	}	197,105✔
279	_current = std::next(_current, diff);	463,858✔
280	_position = (sum - diff * digits);	463,858✔
281	return *this;	463,858✔
282	}	463,858✔
283
284	// Decrements the iterator by several bits and returns it
285	template <class Iterator>
286	constexpr bit_iterator<Iterator>& bit_iterator<Iterator>::operator-=(difference_type n) {	56,617✔
287	constexpr difference_type digits = binary_digits<word_type>::value;	56,617✔
288	const difference_type sum = _position - n;	56,617✔
289	difference_type diff = sum / digits;	56,617✔
290	if (sum < 0 && diff * digits != sum) {	56,617✔
291	--diff;	35,149✔
292	}	35,149✔
293	_current = std::next(_current, diff);	56,617✔
294	_position = (sum - diff * digits);	56,617✔
295	return *this;	56,617✔
296	}	56,617✔
297	// -------------------------------------------------------------------------- //
298
299	template <class Iterator>
300	constexpr bit_iterator<Iterator>::difference_type
301	bit_iterator<Iterator>::operator-(const bit_iterator<Iterator>& other) const {	486,310✔
302	constexpr difference_type digits = binary_digits<word_type>::value;	486,310✔
303	return (_current - other._current) * digits + (_position - other._position);	486,310✔
304	}	486,310✔
305
306	// -------------------- BIT ITERATOR: UNDERLYING DETAILS -------------------- //
307	// Returns a copy of the underlying iterator
308	template <class Iterator>
309	constexpr typename bit_iterator<Iterator>::iterator_type bit_iterator<Iterator>::base() const {	13,269,405✔
310	return _current;	13,269,405✔
311	}	13,269,405✔
312
313	template <class Iterator>
314	constexpr typename bit_iterator<Iterator>::iterator_type bit_iterator<Iterator>::address() const {
315	return _current;
316	}
317
318	// Returns the position of the bit within the underlying word
319	template <class Iterator>
320	constexpr typename bit_iterator<Iterator>::size_type bit_iterator<Iterator>::position() const noexcept {	7,385,972✔
321	return _position;	7,385,972✔
322	}	7,385,972✔
323
324	// -------------- BIT ITERATOR: NON-MEMBER ARITHMETIC OPERATORS ------------- //
325	// Advances the bit iterator several times
326	template <class T>
327	constexpr bit_iterator<T> operator+(typename bit_iterator<T>::difference_type n, const bit_iterator<T>& i) {
328	return i + n;
329	}
330
331	// Computes the distance in bits separating two bit iterators
332	template <class T, class U>
333	constexpr typename std::common_type<
334	typename bit_iterator<T>::difference_type,
335	typename bit_iterator<U>::difference_type>::type
336	operator-(const bit_iterator<T>& lhs, const bit_iterator<U>& rhs) {
337	using lhs_utype = typename bit_iterator<T>::word_type;
338	using rhs_utype = typename bit_iterator<U>::word_type;
339	using lhs_type = typename bit_iterator<T>::difference_type;
340	using rhs_type = typename bit_iterator<U>::difference_type;
341	using difference_type = typename std::common_type<lhs_type, rhs_type>::type;
342	constexpr difference_type lhs_digits = binary_digits<lhs_utype>::value;
343	constexpr difference_type rhs_digits = binary_digits<rhs_utype>::value;
344	constexpr difference_type digits = rhs_digits;
345	static_assert(lhs_digits == rhs_digits, "");
346	const difference_type main = lhs._current - rhs._current;
347	return main * digits + (lhs._position - rhs._position);
348	}
349
350	static_assert(bit_iterator_c<bit_iterator<uint8_t*>>, "bit_iterator does not satisfy bit_iterator_c concept!");
351	static_assert(bit_pointer_c<bit_pointer<uint8_t>, bit_reference<uint8_t>>, "bit_pointer does not satisfy bit_pointer_c concept!");
352	static_assert(bit_iterator_c<bit_pointer<uint8_t>>, "bit_pointer does not satisfy bit_iterator_c concept!");
353
354	// ========================================================================== //
355	} // namespace bit
356	#endif // _BIT_ITERATOR_HPP_INCLUDED
357	// ========================================================================== //

PeterCDMcLean / BitLib / 14987214130

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous