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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef INCLUDED_O3TL_ARRAY_VIEW_HXX
#define INCLUDED_O3TL_ARRAY_VIEW_HXX
#include <sal/config.h>
#include <algorithm>
#include <cstddef>
#include <ios>
#include <iterator>
#include <ostream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <config_global.h>
#include <rtl/string.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#if HAVE_CXX14_CONSTEXPR
#define CONSTEXPR constexpr
#else
#define CONSTEXPR
#endif
namespace o3tl {
#if defined _MSC_VER
#pragma warning(push, 1)
#pragma warning(disable: 4814) // in C++14 'constexpr' will not imply 'const'
#endif
/** A barebones approximation of C++17(?) <array_view>.
Haven't bothered with more than single-dimensional arrays.
*/
template<typename T>
class array_view {
friend class array_view<T const>;
public:
using value_type = T;
using pointer = value_type *;
using const_pointer = value_type const *;
using reference = value_type &;
using const_reference = value_type const &;
using const_iterator = const_pointer;
using iterator = pointer;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using reverse_iterator = std::reverse_iterator<iterator>;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
static constexpr size_type npos = size_type(-1);
constexpr array_view() noexcept : data_(nullptr), size_(0) {}
template<size_type N>
CONSTEXPR array_view (T (&a)[N]) noexcept : data_(a), size_(N) {}
CONSTEXPR array_view (T *a, size_type len) noexcept
: data_(a), size_(len)
{
#if HAVE_CXX14_CONSTEXPR
// not terribly sure about this, might need to relax it
assert((a == nullptr && len == 0) || (a != nullptr && len > 0));
#endif
}
/// Allow for assigning array_view<T> to array_view<T const> i.e.
/// array_view<T> a;
/// array_view<T const> b = a;
template<typename = std::enable_if< std::is_const<value_type>::value > >
array_view& operator=(array_view<typename std::remove_const<value_type>::type> const & other)
{
data_ = other.data_;
size_ = other.size_;
return *this;
}
array_view& operator=(array_view const & other)
{
data_ = other.data_;
size_ = other.size_;
return *this;
}
constexpr bool empty() const noexcept { return size_ == 0; }
constexpr iterator begin() const noexcept { return data_; }
constexpr iterator end() const noexcept { return begin() + size(); }
constexpr const_iterator cbegin() const noexcept { return begin(); }
constexpr const_iterator cend() const noexcept { return end(); }
reverse_iterator rbegin() const noexcept
{ return reverse_iterator(end()); }
reverse_iterator rend() const noexcept
{ return reverse_iterator(begin()); }
constexpr const_reverse_iterator crbegin() const noexcept
{ return rbegin(); }
constexpr const_reverse_iterator crend() const noexcept { return rend(); }
constexpr size_type size() const noexcept { return size_; }
constexpr size_type length() const noexcept { return size(); }
#if !defined __clang__ || HAVE_CXX14_CONSTEXPR
constexpr
#endif
size_type max_size() const noexcept {
#if defined __clang__ // avoid constexpr issues with other, older compilers
(void) this; // loplugin:staticmethods
#endif
return npos - 1;
}
constexpr reference operator [](size_type pos) const {
#if HAVE_CXX14_CONSTEXPR
assert(pos < size());
#endif
return data_[pos];
}
CONSTEXPR
reference at(size_type pos) const {
if (pos >= size()) {
throw std::out_of_range("o3tl::array_view::at");
}
return operator [](pos);
}
constexpr reference front() const {
#if HAVE_CXX14_CONSTEXPR
assert(!empty());
#endif
return operator [](0);
}
constexpr reference back() const {
#if HAVE_CXX14_CONSTEXPR
assert(!empty());
#endif
return operator [](size() - 1);
}
constexpr pointer data() const noexcept { return data_; }
CONSTEXPR void swap(array_view & s) noexcept {
std::swap(data_, s.data_);
std::swap(size_, s.size_);
}
/// so we can use it in associative containers
constexpr bool operator<(array_view const & other) const noexcept {
return data_ < other.data_ && size_ < other.size_;
}
private:
pointer data_;
size_type size_;
};
#if defined _MSC_VER
#pragma warning(pop)
#endif
} // namespace o3tl
namespace std {
template<typename T>
struct hash<o3tl::array_view<T>> {
std::size_t operator()(o3tl::array_view<T> s) const
{ return hash<T[]>()(s.data(), s.size()); }
};
} // namespace std
#undef CONSTEXPR
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
|
