1//
2// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
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/boostorg/beast
8//
9
10#ifndef BOOST_BEAST_IMPL_BUFFERS_SUFFIX_HPP
11#define BOOST_BEAST_IMPL_BUFFERS_SUFFIX_HPP
12
13#include <boost/beast/core/buffer_traits.hpp>
14#include <boost/beast/core/buffer_traits.hpp>
15#include <boost/type_traits.hpp>
16#include <algorithm>
17#include <cstdint>
18#include <iterator>
19#include <type_traits>
20#include <utility>
21
22namespace boost {
23namespace beast {
24
25template<class Buffers>
26class buffers_suffix<Buffers>::const_iterator
27{
28 friend class buffers_suffix<Buffers>;
29
30 using iter_type = buffers_iterator_type<Buffers>;
31
32 iter_type it_{};
33 buffers_suffix const* b_ = nullptr;
34
35public:
36#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
37 using value_type = typename std::conditional<
38 boost::is_convertible<typename
39 std::iterator_traits<iter_type>::value_type,
40 net::mutable_buffer>::value,
41 net::mutable_buffer,
42 net::const_buffer>::type;
43#else
44 using value_type = buffers_type<Buffers>;
45#endif
46 using pointer = value_type const*;
47 using reference = value_type;
48 using difference_type = std::ptrdiff_t;
49 using iterator_category =
50 std::bidirectional_iterator_tag;
51
52 const_iterator() = default;
53 const_iterator(
54 const_iterator const& other) = default;
55 const_iterator& operator=(
56 const_iterator const& other) = default;
57
58 bool
59 operator==(const_iterator const& other) const
60 {
61 return b_ == other.b_ && it_ == other.it_;
62 }
63
64 bool
65 operator!=(const_iterator const& other) const
66 {
67 return !(*this == other);
68 }
69
70 reference
71 operator*() const
72 {
73 if(it_ == b_->begin_)
74 return value_type(*it_) + b_->skip_;
75 return value_type(*it_);
76 }
77
78 pointer
79 operator->() const = delete;
80
81 const_iterator&
82 operator++()
83 {
84 ++it_;
85 return *this;
86 }
87
88 const_iterator
89 operator++(int)
90 {
91 auto temp = *this;
92 ++(*this);
93 return temp;
94 }
95
96 const_iterator&
97 operator--()
98 {
99 --it_;
100 return *this;
101 }
102
103 const_iterator
104 operator--(int)
105 {
106 auto temp = *this;
107 --(*this);
108 return temp;
109 }
110
111private:
112 const_iterator(
113 buffers_suffix const& b,
114 iter_type it)
115 : it_(it)
116 , b_(&b)
117 {
118 }
119};
120
121//------------------------------------------------------------------------------
122
123template<class Buffers>
124buffers_suffix<Buffers>::
125buffers_suffix()
126 : begin_(net::buffer_sequence_begin(bs_))
127{
128}
129
130template<class Buffers>
131buffers_suffix<Buffers>::
132buffers_suffix(buffers_suffix const& other)
133 : buffers_suffix(other,
134 std::distance<iter_type>(
135 net::buffer_sequence_begin(
136 other.bs_), other.begin_))
137{
138}
139
140template<class Buffers>
141buffers_suffix<Buffers>::
142buffers_suffix(Buffers const& bs)
143 : bs_(bs)
144 , begin_(net::buffer_sequence_begin(bs_))
145{
146 static_assert(
147 net::is_const_buffer_sequence<Buffers>::value ||
148 net::is_mutable_buffer_sequence<Buffers>::value,
149 "BufferSequence type requirements not met");
150}
151
152template<class Buffers>
153template<class... Args>
154buffers_suffix<Buffers>::
155buffers_suffix(boost::in_place_init_t, Args&&... args)
156 : bs_(std::forward<Args>(args)...)
157 , begin_(net::buffer_sequence_begin(bs_))
158{
159 static_assert(sizeof...(Args) > 0,
160 "Missing constructor arguments");
161 static_assert(
162 std::is_constructible<Buffers, Args...>::value,
163 "Buffers not constructible from arguments");
164}
165
166template<class Buffers>
167auto
168buffers_suffix<Buffers>::
169operator=(buffers_suffix const& other) ->
170 buffers_suffix&
171{
172 auto const dist = std::distance<iter_type>(
173 net::buffer_sequence_begin(other.bs_),
174 other.begin_);
175 bs_ = other.bs_;
176 begin_ = std::next(
177 net::buffer_sequence_begin(bs_), dist);
178 skip_ = other.skip_;
179 return *this;
180}
181
182template<class Buffers>
183auto
184buffers_suffix<Buffers>::
185begin() const ->
186 const_iterator
187{
188 return const_iterator{*this, begin_};
189}
190
191template<class Buffers>
192auto
193buffers_suffix<Buffers>::
194end() const ->
195 const_iterator
196{
197 return const_iterator{*this,
198 net::buffer_sequence_end(bs_)};
199}
200
201template<class Buffers>
202void
203buffers_suffix<Buffers>::
204consume(std::size_t amount)
205{
206 auto const end =
207 net::buffer_sequence_end(bs_);
208 for(;amount > 0 && begin_ != end; ++begin_)
209 {
210 auto const len =
211 buffer_bytes(*begin_) - skip_;
212 if(amount < len)
213 {
214 skip_ += amount;
215 break;
216 }
217 amount -= len;
218 skip_ = 0;
219 }
220}
221
222} // beast
223} // boost
224
225#endif
226

source code of boost/libs/beast/include/boost/beast/core/impl/buffers_suffix.hpp