[ceph.git] / ceph / src / Beast / include / beast / core / detail / buffer_cat.hpp

//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BEAST_DETAIL_BUFFER_CAT_HPP
#define BEAST_DETAIL_BUFFER_CAT_HPP

#include <beast/core/buffer_concepts.hpp>
#include <beast/core/detail/type_traits.hpp>
#include <boost/asio/buffer.hpp>
#include <cstdint>
#include <iterator>
#include <new>
#include <stdexcept>
#include <tuple>
#include <utility>

namespace beast {
namespace detail {

template<class... Bn>
struct common_buffers_type
{
    using type = typename std::conditional<
        std::is_convertible<std::tuple<Bn...>,
            typename repeat_tuple<sizeof...(Bn),
                boost::asio::mutable_buffer>::type>::value,
                    boost::asio::mutable_buffer,
                        boost::asio::const_buffer>::type;
};

template<class... Bn>
class buffer_cat_helper
{
    std::tuple<Bn...> bn_;

public:
    using value_type = typename
        common_buffers_type<Bn...>::type;

    class const_iterator;

    buffer_cat_helper(buffer_cat_helper&&) = default;
    buffer_cat_helper(buffer_cat_helper const&) = default;
    buffer_cat_helper& operator=(buffer_cat_helper&&) = delete;
    buffer_cat_helper& operator=(buffer_cat_helper const&) = delete;

    explicit
    buffer_cat_helper(Bn const&... bn)
        : bn_(bn...)
    {
    }

    const_iterator
    begin() const;

    const_iterator
    end() const;
};

template<class... Bn>
class buffer_cat_helper<Bn...>::const_iterator
{
    std::size_t n_;
    std::tuple<Bn...> const* bn_;
    std::array<std::uint8_t,
        max_sizeof<typename Bn::const_iterator...>()> buf_;

    friend class buffer_cat_helper<Bn...>;

    template<std::size_t I>
    using C = std::integral_constant<std::size_t, I>;

    template<std::size_t I>
    using iter_t = typename std::tuple_element<
        I, std::tuple<Bn...>>::type::const_iterator;

    template<std::size_t I>
    iter_t<I>&
    iter()
    {
        // type-pun
        return *reinterpret_cast<
            iter_t<I>*>(static_cast<void*>(
                buf_.data()));
    }

    template<std::size_t I>
    iter_t<I> const&
    iter() const
    {
        // type-pun
        return *reinterpret_cast<
            iter_t<I> const*>(static_cast<
                void const*>(buf_.data()));
    }

public:
    using value_type = typename
        common_buffers_type<Bn...>::type;
    using pointer = value_type const*;
    using reference = value_type;
    using difference_type = std::ptrdiff_t;
    using iterator_category =
        std::bidirectional_iterator_tag;

    ~const_iterator();
    const_iterator();
    const_iterator(const_iterator&& other);
    const_iterator(const_iterator const& other);
    const_iterator& operator=(const_iterator&& other);
    const_iterator& operator=(const_iterator const& other);

    bool
    operator==(const_iterator const& other) const;

    bool
    operator!=(const_iterator const& other) const
    {
        return !(*this == other);
    }

    reference
    operator*() const;

    pointer
    operator->() const = delete;

    const_iterator&
    operator++();

    const_iterator
    operator++(int)
    {
        auto temp = *this;
        ++(*this);
        return temp;
    }

    const_iterator&
    operator--();

    const_iterator
    operator--(int)
    {
        auto temp = *this;
        --(*this);
        return temp;
    }

private:
    const_iterator(
        std::tuple<Bn...> const& bn, bool at_end);

    void
    construct(C<sizeof...(Bn)> const&)
    {
        auto constexpr I = sizeof...(Bn);
        n_ = I;
    }

    template<std::size_t I>
    void
    construct(C<I> const&)
    {
        if(std::get<I>(*bn_).begin() !=
            std::get<I>(*bn_).end())
        {
            n_ = I;
            new(buf_.data()) iter_t<I>{
                std::get<I>(*bn_).begin()};
            return;
        }
        construct(C<I+1>{});
    }

    void
    destroy(C<sizeof...(Bn)> const&)
    {
        return;
    }

    template<std::size_t I>
    void
    destroy(C<I> const&)
    {
        if(n_ == I)
        {
            using Iter = iter_t<I>;
            iter<I>().~Iter();
            return;
        }
        destroy(C<I+1>{});
    }

    void
    move(const_iterator&&,
        C<sizeof...(Bn)> const&)
    {
    }

    template<std::size_t I>
    void
    move(const_iterator&& other,
        C<I> const&)
    {
        if(n_ == I)
        {
            new(buf_.data()) iter_t<I>{
                std::move(other.iter<I>())};
            return;
        }
        move(std::move(other), C<I+1>{});
    }

    void
    copy(const_iterator const&,
        C<sizeof...(Bn)> const&)
    {
    }

    template<std::size_t I>
    void
    copy(const_iterator const& other,
        C<I> const&)
    {
        if(n_ == I)
        {
            new(buf_.data()) iter_t<I>{
                other.iter<I>()};
            return;
        }
        copy(other, C<I+1>{});
    }

    bool
    equal(const_iterator const&,
        C<sizeof...(Bn)> const&) const
    {
        return true;
    }

    template<std::size_t I>
    bool
    equal(const_iterator const& other,
        C<I> const&) const
    {
        if(n_ == I)
            return iter<I>() == other.iter<I>();
        return equal(other, C<I+1>{});
    }

    [[noreturn]]
    reference
    dereference(C<sizeof...(Bn)> const&) const
    {
        throw detail::make_exception<std::logic_error>(
            "invalid iterator", __FILE__, __LINE__);
    }

    template<std::size_t I>
    reference
    dereference(C<I> const&) const
    {
        if(n_ == I)
            return *iter<I>();
        return dereference(C<I+1>{});
    }

    [[noreturn]]
    void
    increment(C<sizeof...(Bn)> const&)
    {
        throw detail::make_exception<std::logic_error>(
            "invalid iterator", __FILE__, __LINE__);
    }

    template<std::size_t I>
    void
    increment(C<I> const&)
    {
        if(n_ == I)
        {
            if(++iter<I>() !=
                    std::get<I>(*bn_).end())
                return;
            using Iter = iter_t<I>;
            iter<I>().~Iter();
            return construct(C<I+1>{});
        }
        increment(C<I+1>{});
    }

    void
    decrement(C<sizeof...(Bn)> const&)
    {
        auto constexpr I = sizeof...(Bn);
        if(n_ == I)
        {
            --n_;
            new(buf_.data()) iter_t<I-1>{
                std::get<I-1>(*bn_).end()};
        }
        decrement(C<I-1>{});
    }

    void
    decrement(C<0> const&)
    {
        auto constexpr I = 0;
        if(iter<I>() != std::get<I>(*bn_).begin())
        {
            --iter<I>();
            return;
        }
        throw detail::make_exception<std::logic_error>(
            "invalid iterator", __FILE__, __LINE__);
    }

    template<std::size_t I>
    void
    decrement(C<I> const&)
    {
        if(n_ == I)
        {
            if(iter<I>() != std::get<I>(*bn_).begin())
            {
                --iter<I>();
                return;
            }
            --n_;
            using Iter = iter_t<I>;
            iter<I>().~Iter();
            new(buf_.data()) iter_t<I-1>{
                std::get<I-1>(*bn_).end()};
        }
        decrement(C<I-1>{});
    }
};

//------------------------------------------------------------------------------

template<class... Bn>
buffer_cat_helper<Bn...>::
const_iterator::~const_iterator()
{
    destroy(C<0>{});
}

template<class... Bn>
buffer_cat_helper<Bn...>::
const_iterator::const_iterator()
    : n_(sizeof...(Bn))
    , bn_(nullptr)
{
}

template<class... Bn>
buffer_cat_helper<Bn...>::
const_iterator::const_iterator(
    std::tuple<Bn...> const& bn, bool at_end)
    : bn_(&bn)
{
    if(at_end)
        n_ = sizeof...(Bn);
    else
        construct(C<0>{});
}

template<class... Bn>
buffer_cat_helper<Bn...>::
const_iterator::const_iterator(const_iterator&& other)
    : n_(other.n_)
    , bn_(other.bn_)
{
    move(std::move(other), C<0>{});
}

template<class... Bn>
buffer_cat_helper<Bn...>::
const_iterator::const_iterator(const_iterator const& other)
    : n_(other.n_)
    , bn_(other.bn_)
{
    copy(other, C<0>{});
}

template<class... Bn>
auto
buffer_cat_helper<Bn...>::
const_iterator::operator=(const_iterator&& other) ->
    const_iterator&
{
    if(&other == this)
        return *this;
    destroy(C<0>{});
    n_ = other.n_;
    bn_ = other.bn_;
    move(std::move(other), C<0>{});
    return *this;
}

template<class... Bn>
auto
buffer_cat_helper<Bn...>::
const_iterator::operator=(const_iterator const& other) ->
const_iterator&
{
    if(&other == this)
        return *this;
    destroy(C<0>{});
    n_ = other.n_;
    bn_ = other.bn_;
    copy(other, C<0>{});
    return *this;
}

template<class... Bn>
bool
buffer_cat_helper<Bn...>::
const_iterator::operator==(const_iterator const& other) const
{
    if(bn_ != other.bn_)
        return false;
    if(n_ != other.n_)
        return false;
    return equal(other, C<0>{});
}

template<class... Bn>
auto
buffer_cat_helper<Bn...>::
const_iterator::operator*() const ->
    reference
{
    return dereference(C<0>{});
}

template<class... Bn>
auto
buffer_cat_helper<Bn...>::
const_iterator::operator++() ->
    const_iterator&
{
    increment(C<0>{});
    return *this;
}

template<class... Bn>
auto
buffer_cat_helper<Bn...>::
const_iterator::operator--() ->
    const_iterator&
{
    decrement(C<sizeof...(Bn)>{});
    return *this;
}

template<class... Bn>
inline
auto
buffer_cat_helper<Bn...>::begin() const ->
    const_iterator
{
    return const_iterator{bn_, false};
}

template<class... Bn>
inline
auto
buffer_cat_helper<Bn...>::end() const ->
    const_iterator
{
    return const_iterator{bn_, true};
}

} // detail
} // beast

#endif
Commit	Line	Data
7c673cae FG	1	//
	2	// Copyright (c) 2013-2017 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
	8	#ifndef BEAST_DETAIL_BUFFER_CAT_HPP
	9	#define BEAST_DETAIL_BUFFER_CAT_HPP
	10
	11	#include <beast/core/buffer_concepts.hpp>
	12	#include <beast/core/detail/type_traits.hpp>
	13	#include <boost/asio/buffer.hpp>
	14	#include <cstdint>
	15	#include <iterator>
	16	#include <new>
	17	#include <stdexcept>
	18	#include <tuple>
	19	#include <utility>
	20
	21	namespace beast {
	22	namespace detail {
	23
	24	template<class... Bn>
	25	struct common_buffers_type
	26	{
	27	using type = typename std::conditional<
	28	std::is_convertible<std::tuple<Bn...>,
	29	typename repeat_tuple<sizeof...(Bn),
	30	boost::asio::mutable_buffer>::type>::value,
	31	boost::asio::mutable_buffer,
	32	boost::asio::const_buffer>::type;
	33	};
	34
	35	template<class... Bn>
	36	class buffer_cat_helper
	37	{
	38	std::tuple<Bn...> bn_;
	39
	40	public:
	41	using value_type = typename
	42	common_buffers_type<Bn...>::type;
	43
	44	class const_iterator;
	45
	46	buffer_cat_helper(buffer_cat_helper&&) = default;
	47	buffer_cat_helper(buffer_cat_helper const&) = default;
	48	buffer_cat_helper& operator=(buffer_cat_helper&&) = delete;
	49	buffer_cat_helper& operator=(buffer_cat_helper const&) = delete;
	50
	51	explicit
	52	buffer_cat_helper(Bn const&... bn)
	53	: bn_(bn...)
	54	{
	55	}
	56
	57	const_iterator
	58	begin() const;
	59
	60	const_iterator
	61	end() const;
	62	};
	63
	64	template<class... Bn>
65	class buffer_cat_helper<Bn...>::const_iterator
66	{
67	std::size_t n_;
68	std::tuple<Bn...> const* bn_;
69	std::array<std::uint8_t,
70	max_sizeof<typename Bn::const_iterator...>()> buf_;
71
72	friend class buffer_cat_helper<Bn...>;
73
74	template<std::size_t I>
75	using C = std::integral_constant<std::size_t, I>;
76
77	template<std::size_t I>
78	using iter_t = typename std::tuple_element<
79	I, std::tuple<Bn...>>::type::const_iterator;
80
81	template<std::size_t I>
82	iter_t<I>&
83	iter()
84	{
85	// type-pun
86	return *reinterpret_cast<
87	iter_t<I>>(static_cast<void>(
88	buf_.data()));
89	}
90
91	template<std::size_t I>
92	iter_t<I> const&
93	iter() const
94	{
95	// type-pun
96	return *reinterpret_cast<
97	iter_t<I> const*>(static_cast<
98	void const*>(buf_.data()));
99	}
100
101	public:
102	using value_type = typename
103	common_buffers_type<Bn...>::type;
104	using pointer = value_type const*;
105	using reference = value_type;
106	using difference_type = std::ptrdiff_t;
107	using iterator_category =
108	std::bidirectional_iterator_tag;
109
110	~const_iterator();
111	const_iterator();
112	const_iterator(const_iterator&& other);
113	const_iterator(const_iterator const& other);
114	const_iterator& operator=(const_iterator&& other);
115	const_iterator& operator=(const_iterator const& other);
116
117	bool
118	operator==(const_iterator const& other) const;
119
120	bool
121	operator!=(const_iterator const& other) const
122	{
123	return !(*this == other);
124	}
125
126	reference
127	operator*() const;
128
129	pointer
130	operator->() const = delete;
131
132	const_iterator&
133	operator++();
134
135	const_iterator
136	operator++(int)
137	{
138	auto temp = *this;
139	++(*this);
140	return temp;
141	}
142
143	const_iterator&
144	operator--();
145
146	const_iterator
147	operator--(int)
148	{
149	auto temp = *this;
150	--(*this);
151	return temp;
152	}
153
154	private:
155	const_iterator(
156	std::tuple<Bn...> const& bn, bool at_end);
157
158	void
159	construct(C<sizeof...(Bn)> const&)
160	{
161	auto constexpr I = sizeof...(Bn);
162	n_ = I;
163	}
164
165	template<std::size_t I>
166	void
167	construct(C<I> const&)
168	{
169	if(std::get<I>(*bn_).begin() !=
170	std::get<I>(*bn_).end())
171	{
172	n_ = I;
173	new(buf_.data()) iter_t<I>{
174	std::get<I>(*bn_).begin()};
175	return;
176	}
177	construct(C<I+1>{});
178	}
179
180	void
181	destroy(C<sizeof...(Bn)> const&)
182	{
183	return;
184	}
185
186	template<std::size_t I>
187	void
188	destroy(C<I> const&)
189	{
190	if(n_ == I)
191	{
192	using Iter = iter_t<I>;
193	iter<I>().~Iter();
194	return;
195	}
196	destroy(C<I+1>{});
197	}
198
199	void
200	move(const_iterator&&,
201	C<sizeof...(Bn)> const&)
202	{
203	}
204
205	template<std::size_t I>
206	void
207	move(const_iterator&& other,
208	C<I> const&)
209	{
210	if(n_ == I)
211	{
212	new(buf_.data()) iter_t<I>{
213	std::move(other.iter<I>())};
214	return;
215	}
216	move(std::move(other), C<I+1>{});
217	}
218
219	void
220	copy(const_iterator const&,
221	C<sizeof...(Bn)> const&)
222	{
223	}
224
225	template<std::size_t I>
226	void
227	copy(const_iterator const& other,
228	C<I> const&)
229	{
230	if(n_ == I)
231	{
232	new(buf_.data()) iter_t<I>{
233	other.iter<I>()};
234	return;
235	}
236	copy(other, C<I+1>{});
237	}
238
239	bool
240	equal(const_iterator const&,
241	C<sizeof...(Bn)> const&) const
242	{
243	return true;
244	}
245
246	template<std::size_t I>
247	bool
248	equal(const_iterator const& other,
249	C<I> const&) const
250	{
251	if(n_ == I)
252	return iter<I>() == other.iter<I>();
253	return equal(other, C<I+1>{});
254	}
255
256	[[noreturn]]
257	reference
258	dereference(C<sizeof...(Bn)> const&) const
259	{
260	throw detail::make_exception<std::logic_error>(
261	"invalid iterator", __FILE__, __LINE__);
262	}
263
264	template<std::size_t I>
265	reference
266	dereference(C<I> const&) const
267	{
268	if(n_ == I)
269	return *iter<I>();
270	return dereference(C<I+1>{});
271	}
272
273	[[noreturn]]
274	void
275	increment(C<sizeof...(Bn)> const&)
276	{
277	throw detail::make_exception<std::logic_error>(
278	"invalid iterator", __FILE__, __LINE__);
279	}
280
281	template<std::size_t I>
282	void
283	increment(C<I> const&)
284	{
285	if(n_ == I)
286	{
287	if(++iter<I>() !=
288	std::get<I>(*bn_).end())
289	return;
290	using Iter = iter_t<I>;
291	iter<I>().~Iter();
292	return construct(C<I+1>{});
293	}
294	increment(C<I+1>{});
295	}
296
297	void
298	decrement(C<sizeof...(Bn)> const&)
299	{
300	auto constexpr I = sizeof...(Bn);
301	if(n_ == I)
302	{
303	--n_;
304	new(buf_.data()) iter_t<I-1>{
305	std::get<I-1>(*bn_).end()};
306	}
307	decrement(C<I-1>{});
308	}
309
310	void
311	decrement(C<0> const&)
312	{
313	auto constexpr I = 0;
314	if(iter<I>() != std::get<I>(*bn_).begin())
315	{
316	--iter<I>();
317	return;
318	}
319	throw detail::make_exception<std::logic_error>(
320	"invalid iterator", __FILE__, __LINE__);
321	}
322
323	template<std::size_t I>
324	void
325	decrement(C<I> const&)
326	{
327	if(n_ == I)
328	{
329	if(iter<I>() != std::get<I>(*bn_).begin())
330	{
331	--iter<I>();
332	return;
333	}
334	--n_;
335	using Iter = iter_t<I>;
336	iter<I>().~Iter();
337	new(buf_.data()) iter_t<I-1>{
338	std::get<I-1>(*bn_).end()};
339	}
340	decrement(C<I-1>{});
341	}
342	};
343
344	//------------------------------------------------------------------------------
345
346	template<class... Bn>
347	buffer_cat_helper<Bn...>::
348	const_iterator::~const_iterator()
349	{
350	destroy(C<0>{});
351	}
352
353	template<class... Bn>
354	buffer_cat_helper<Bn...>::
355	const_iterator::const_iterator()
356	: n_(sizeof...(Bn))
357	, bn_(nullptr)
358	{
359	}
360
361	template<class... Bn>
362	buffer_cat_helper<Bn...>::
363	const_iterator::const_iterator(
364	std::tuple<Bn...> const& bn, bool at_end)
365	: bn_(&bn)
366	{
367	if(at_end)
368	n_ = sizeof...(Bn);
369	else
370	construct(C<0>{});
371	}
372
373	template<class... Bn>
374	buffer_cat_helper<Bn...>::
375	const_iterator::const_iterator(const_iterator&& other)
376	: n_(other.n_)
377	, bn_(other.bn_)
378	{
379	move(std::move(other), C<0>{});
380	}
381
382	template<class... Bn>
383	buffer_cat_helper<Bn...>::
384	const_iterator::const_iterator(const_iterator const& other)
385	: n_(other.n_)
386	, bn_(other.bn_)
387	{
388	copy(other, C<0>{});
389	}
390
391	template<class... Bn>
392	auto
393	buffer_cat_helper<Bn...>::
394	const_iterator::operator=(const_iterator&& other) ->
395	const_iterator&
396	{
397	if(&other == this)
398	return *this;
399	destroy(C<0>{});
400	n_ = other.n_;
401	bn_ = other.bn_;
402	move(std::move(other), C<0>{});
403	return *this;
404	}
405
406	template<class... Bn>
407	auto
408	buffer_cat_helper<Bn...>::
409	const_iterator::operator=(const_iterator const& other) ->
410	const_iterator&
411	{
412	if(&other == this)
413	return *this;
414	destroy(C<0>{});
415	n_ = other.n_;
416	bn_ = other.bn_;
417	copy(other, C<0>{});
418	return *this;
419	}
420
421	template<class... Bn>
422	bool
423	buffer_cat_helper<Bn...>::
424	const_iterator::operator==(const_iterator const& other) const
425	{
426	if(bn_ != other.bn_)
427	return false;
428	if(n_ != other.n_)
429	return false;
430	return equal(other, C<0>{});
431	}
432
433	template<class... Bn>
434	auto
435	buffer_cat_helper<Bn...>::
436	const_iterator::operator*() const ->
437	reference
438	{
439	return dereference(C<0>{});
440	}
441
442	template<class... Bn>
443	auto
444	buffer_cat_helper<Bn...>::
445	const_iterator::operator++() ->
446	const_iterator&
447	{
448	increment(C<0>{});
449	return *this;
450	}
451
452	template<class... Bn>
453	auto
454	buffer_cat_helper<Bn...>::
455	const_iterator::operator--() ->
456	const_iterator&
457	{
458	decrement(C<sizeof...(Bn)>{});
459	return *this;
460	}
461
462	template<class... Bn>
463	inline
464	auto
465	buffer_cat_helper<Bn...>::begin() const ->
466	const_iterator
467	{
468	return const_iterator{bn_, false};
469	}
470
471	template<class... Bn>
472	inline
473	auto
474	buffer_cat_helper<Bn...>::end() const ->
475	const_iterator
476	{
477	return const_iterator{bn_, true};
478	}
479
480	} // detail
481	} // beast
482
483	#endif