include/boost/capy/detail/slice_of.hpp

100.0% Lines (72 / 72) 92.8% Functions (141 / 152)

[ ] prev/next file

slice_of.hpp

f(x) Functions (152)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Steve Gerbino
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/capy
8		//
9
10		#ifndef BOOST_CAPY_DETAIL_SLICE_OF_HPP
11		#define BOOST_CAPY_DETAIL_SLICE_OF_HPP
12
13		#include <boost/capy/detail/config.hpp>
14		#include <boost/capy/buffers.hpp>
15
16		#include <cstddef>
17		#include <iterator>
18		#include <limits>
19		#include <type_traits>
20
21		namespace boost {
22		namespace capy {
23		namespace detail {
24
25		/** A borrowed view over a byte sub-range of a buffer sequence.
26
27		`slice_of<BS>` is the view `consuming_buffers::data()` returns. It
28		models the same buffer-sequence concept as `BS`:
29		`MutableBufferSequence` if `BS` is mutable, otherwise
30		`ConstBufferSequence`. It can therefore be passed anywhere a buffer
31		sequence is expected.
32
33		It stores iterators into the underlying sequence plus front/back byte
34		offsets; it neither owns nor copies the descriptors. The underlying
35		sequence must outlive the view.
36
37		@par Complexity
38		Construction is a single forward pass to the cut points. It is
39		O(buffers up to `offset`) for a to-end slice, and O(buffers up to
40		`offset + length`) for a bounded slice. It never sums the whole
41		sequence.
42		*/
43		template<class BS>
44		requires ConstBufferSequence<BS>
45		class slice_of
46		{
47		public:
48		/// The buffer type yielded by iteration.
49		using buffer_type = capy::buffer_type<BS>;
50
51		/// The underlying sequence's iterator type.
52		using iterator_type =
53		decltype(capy::buffer_sequence_begin(std::declval<BS const&>()));
54
55		private:
56		iterator_type first_{};
57		iterator_type last_{};
58		std::size_t front_skip_ = 0; // bytes trimmed from *first_
59		std::size_t back_skip_ = 0; // bytes trimmed from the final buffer
60
61		static buffer_type
62	34135x	adjust(buffer_type const& b,
63		std::size_t front_n, std::size_t back_n) noexcept
64		{
65		if constexpr (std::is_same_v<buffer_type, mutable_buffer>)
66	17004x	return mutable_buffer(
67	17004x	static_cast<char*>(b.data()) + front_n,
68	34008x	b.size() - front_n - back_n);
69		else
70	17131x	return const_buffer(
71	17131x	static_cast<char const*>(b.data()) + front_n,
72	34262x	b.size() - front_n - back_n);
73		}
74
75		public:
76		/// Bidirectional iterator that adjusts the first and last buffers.
77		class const_iterator
78		{
79		iterator_type cur_{};
80		iterator_type anchor_first_{};
81		iterator_type anchor_last_{};
82		std::size_t front_skip_ = 0;
83		std::size_t back_skip_ = 0;
84
85		public:
86		using iterator_category = std::bidirectional_iterator_tag;
87		using value_type = buffer_type;
88		using difference_type = std::ptrdiff_t;
89		using pointer = value_type*;
90		using reference = value_type;
91
92		const_iterator() noexcept = default;
93
94	51125x	const_iterator(
95		iterator_type cur, iterator_type anchor_first,
96		iterator_type anchor_last, std::size_t front_skip,
97		std::size_t back_skip) noexcept
98	51125x	: cur_(cur)
99	51125x	, anchor_first_(anchor_first)
100	51125x	, anchor_last_(anchor_last)
101	51125x	, front_skip_(front_skip)
102	51125x	, back_skip_(back_skip)
103		{
104	51125x	}
105
106	59189x	bool operator==(const_iterator const& o) const noexcept
107		{
108	59189x	return cur_ == o.cur_;
109		}
110
111	59189x	bool operator!=(const_iterator const& o) const noexcept
112		{
113	59189x	return !(*this == o);
114		}
115
116	34135x	value_type operator*() const noexcept
117		{
118	34135x	buffer_type buf = *cur_;
119	34135x	auto const front_n = (cur_ == anchor_first_) ? front_skip_ : 0;
120	34135x	auto next = cur_;
121	34135x	++next;
122	34135x	auto const back_n = (next == anchor_last_) ? back_skip_ : 0;
123	34135x	return adjust(buf, front_n, back_n);
124		}
125
126	21929x	const_iterator& operator++() noexcept { ++cur_; return *this; }
127	6446x	const_iterator operator++(int) noexcept
128	6446x	{ auto t = this; ++this; return t; }
129	12144x	const_iterator& operator--() noexcept { --cur_; return *this; }
130	6072x	const_iterator operator--(int) noexcept
131	6072x	{ auto t = this; --this; return t; }
132		};
133
134		/// Construct an empty slice.
135		slice_of() noexcept = default;
136
137		/** Construct a view of `[offset, offset + length)` bytes of `bs`.
138
139		@param bs The underlying sequence (must outlive the view).
140		@param offset Bytes skipped from the front. Clamped to the total.
141		@param length Bytes exposed; the default exposes to the end.
142		*/
143	2285x	slice_of(
144		BS const& bs,
145		std::size_t offset,
146		std::size_t length =
147		(std::numeric_limits<std::size_t>::max)()) noexcept
148	2285x	{
149	2285x	first_ = capy::buffer_sequence_begin(bs);
150	2285x	last_ = capy::buffer_sequence_end(bs);
151
152		// Position first_/front_skip_ at byte `offset` (single forward pass).
153	2285x	std::size_t skip = offset;
154	2950x	while (first_ != last_)
155		{
156	2846x	std::size_t const sz = buffer_type(*first_).size();
157	2846x	if (skip < sz)
158		{
159	2181x	front_skip_ = skip;
160	2181x	break;
161		}
162	665x	skip -= sz;
163	665x	++first_;
164		}
165
166	2285x	if (first_ == last_)
167	180x	return; // offset at or past the end: empty slice
168	2181x	if (length == (std::numeric_limits<std::size_t>::max)())
169	1039x	return; // to-end: last_ already at the end, back_skip_ == 0
170
171		// Walk `length` live bytes forward to fix last_/back_skip_.
172	1142x	std::size_t left = length;
173	1142x	auto cursor = first_;
174	1142x	std::size_t cursor_front = front_skip_;
175	1637x	while (cursor != last_ && left > 0)
176		{
177	1533x	std::size_t const sz = buffer_type(*cursor).size();
178	1533x	std::size_t const avail = sz - cursor_front;
179	1533x	if (left <= avail)
180		{
181	1038x	back_skip_ = avail - left;
182	1038x	++cursor;
183	1038x	last_ = cursor;
184	1038x	return;
185		}
186	495x	left -= avail;
187	495x	++cursor;
188	495x	cursor_front = 0;
189		}
190	104x	last_ = cursor;
191		}
192
193		/** Construct directly from a positioned iterator range.
194
195		Used by `consuming_buffers::data()` to expose its current position
196		without re-walking from the start.
197		*/
198	354x	slice_of(
199		iterator_type first, iterator_type last,
200		std::size_t front_skip = 0, std::size_t back_skip = 0) noexcept
201	354x	: first_(first)
202	354x	, last_(last)
203	354x	, front_skip_(front_skip)
204	354x	, back_skip_(back_skip)
205		{
206	354x	}
207
208		/// Return an iterator to the first buffer.
209	25555x	const_iterator begin() const noexcept
210		{
211		return const_iterator(
212	25555x	first_, first_, last_, front_skip_, back_skip_);
213		}
214
215		/// Return an iterator past the last buffer.
216	25570x	const_iterator end() const noexcept
217		{
218		return const_iterator(
219	25570x	last_, first_, last_, front_skip_, back_skip_);
220		}
221		};
222
223		} // namespace detail
224		} // namespace capy
225		} // namespace boost
226
227		#endif
228