1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
/*!
@file
Adapts `std::vector` for use with Hana.
@copyright Louis Dionne 2013-2017
@copyright Gonzalo Brito Gadeschi 2015
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_HANA_EXT_STD_VECTOR_HPP
#define BOOST_HANA_EXT_STD_VECTOR_HPP
#include <boost/hana/config.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/fwd/core/tag_of.hpp>
#include <boost/hana/less.hpp>
#include <algorithm>
#include <iterator>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
BOOST_HANA_NAMESPACE_BEGIN
namespace ext { namespace std { struct vector_tag; }}
template <typename T, typename Allocator>
struct tag_of<std::vector<T, Allocator>> {
using type = ext::std::vector_tag;
};
//////////////////////////////////////////////////////////////////////////
// Comparable
//////////////////////////////////////////////////////////////////////////
template <>
struct equal_impl<ext::std::vector_tag, ext::std::vector_tag> {
template <typename T1, typename A1, typename T2, typename A2>
static bool apply(std::vector<T1, A1> const& v1,
std::vector<T2, A2> const& v2)
{
return std::equal(begin(v1), end(v1),
begin(v2), end(v2),
hana::equal);
}
};
//////////////////////////////////////////////////////////////////////////
// Orderable
//////////////////////////////////////////////////////////////////////////
template <>
struct less_impl<ext::std::vector_tag, ext::std::vector_tag> {
template <typename T1, typename A1, typename T2, typename A2>
static bool apply(std::vector<T1, A1> const& v1,
std::vector<T2, A2> const& v2)
{
return std::lexicographical_compare(begin(v1), end(v1),
begin(v2), end(v2),
hana::less);
}
};
#if 0
//////////////////////////////////////////////////////////////////////////
// Functor
//////////////////////////////////////////////////////////////////////////
template <>
struct transform_impl<ext::std::vector_tag> {
template <typename V, typename F>
static auto apply(V&& v, F&& f) {
using U = std::remove_cv_t<std::remove_reference_t<
decltype(f(*v.begin()))
>>;
using Alloc = typename std::remove_reference_t<V>::allocator_type;
using NewAlloc = typename std::allocator_traits<Alloc>::
template rebind_alloc<U>;
std::vector<U, NewAlloc> result; result.reserve(v.size());
std::transform(begin(v), end(v),
std::back_inserter(result), std::forward<F>(f));
return result;
}
template <typename T, typename Alloc, typename F>
static auto apply(std::vector<T, Alloc>&& v, F&& f)
-> std::enable_if_t<
std::is_same<
T,
std::remove_cv_t<std::remove_reference_t<
decltype(f(*v.begin()))
>>
>{}
, std::vector<T, Alloc>
>
{
// If we receive a rvalue and the function returns elements of
// the same type, we modify the vector in-place instead of
// returning a new one.
std::transform(std::make_move_iterator(begin(v)),
std::make_move_iterator(end(v)),
begin(v), std::forward<F>(f));
return std::move(v);
}
};
#endif
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_EXT_STD_VECTOR_HPP
|
