1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ART_LIBARTBASE_BASE_TRANSFORM_ARRAY_REF_H_
18 #define ART_LIBARTBASE_BASE_TRANSFORM_ARRAY_REF_H_
19
20 #include <type_traits>
21
22 #include "array_ref.h"
23 #include "transform_iterator.h"
24
25 namespace art {
26
27 /**
28 * @brief An ArrayRef<> wrapper that uses a transformation function for element access.
29 */
30 template <typename BaseType, typename Function>
31 class TransformArrayRef {
32 private:
33 using Iter = TransformIterator<typename ArrayRef<BaseType>::iterator, Function>;
34
35 // The Function may take a non-const reference, so const_iterator may not exist.
36 struct FallbackConstIter {
37 using pointer = void;
38 using reference = void;
39 };
40 using PreferredConstIter =
41 TransformIterator<typename ArrayRef<BaseType>::const_iterator, Function>;
42 static constexpr bool kHasConstIter = std::is_invocable_v<Function, const BaseType&>;
43 using ConstIter = std::conditional_t<kHasConstIter, PreferredConstIter, FallbackConstIter>;
44
45 public:
46 using value_type = typename Iter::value_type;
47 using reference = typename Iter::reference;
48 using const_reference = typename ConstIter::reference;
49 using pointer = typename Iter::pointer;
50 using const_pointer = typename ConstIter::pointer;
51 using iterator = Iter;
52 using const_iterator = std::conditional_t<kHasConstIter, ConstIter, void>;
53 using reverse_iterator = std::reverse_iterator<Iter>;
54 using const_reverse_iterator =
55 std::conditional_t<kHasConstIter, std::reverse_iterator<ConstIter>, void>;
56 using difference_type = typename ArrayRef<BaseType>::difference_type;
57 using size_type = typename ArrayRef<BaseType>::size_type;
58
59 // Constructors.
60
61 TransformArrayRef(const TransformArrayRef& other) = default;
62
63 template <typename OtherBT>
TransformArrayRef(const ArrayRef<OtherBT> & base,Function fn)64 TransformArrayRef(const ArrayRef<OtherBT>& base, Function fn)
65 : data_(base, fn) { }
66
67 template <typename OtherBT,
68 typename = std::enable_if_t<std::is_same_v<BaseType, const OtherBT>>>
TransformArrayRef(const TransformArrayRef<OtherBT,Function> & other)69 TransformArrayRef(const TransformArrayRef<OtherBT, Function>& other)
70 : TransformArrayRef(other.base(), other.GetFunction()) { }
71
72 // Assignment operators.
73
74 TransformArrayRef& operator=(const TransformArrayRef& other) = default;
75
76 template <typename OtherBT,
77 typename = std::enable_if_t<std::is_same_v<BaseType, const OtherBT>>>
78 TransformArrayRef& operator=(const TransformArrayRef<OtherBT, Function>& other) {
79 return *this = TransformArrayRef(other.base(), other.GetFunction());
80 }
81
82 // Destructor.
83 ~TransformArrayRef() = default;
84
85 // Iterators.
begin()86 iterator begin() { return MakeIterator(base().begin()); }
begin()87 const_iterator begin() const { return MakeIterator(base().cbegin()); }
cbegin()88 const_iterator cbegin() const { return MakeIterator(base().cbegin()); }
end()89 iterator end() { return MakeIterator(base().end()); }
end()90 const_iterator end() const { return MakeIterator(base().cend()); }
cend()91 const_iterator cend() const { return MakeIterator(base().cend()); }
rbegin()92 reverse_iterator rbegin() { return reverse_iterator(end()); }
rbegin()93 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
crbegin()94 const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
rend()95 reverse_iterator rend() { return reverse_iterator(begin()); }
rend()96 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
crend()97 const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
98
99 // Size.
size()100 size_type size() const { return base().size(); }
empty()101 bool empty() const { return base().empty(); }
102
103 // Element access. NOTE: Not providing data().
104
105 reference operator[](size_type n) { return GetFunction()(base()[n]); }
106 const_reference operator[](size_type n) const { return GetFunction()(base()[n]); }
107
front()108 reference front() { return GetFunction()(base().front()); }
front()109 const_reference front() const { return GetFunction()(base().front()); }
110
back()111 reference back() { return GetFunction()(base().back()); }
back()112 const_reference back() const { return GetFunction()(base().back()); }
113
SubArray(size_type pos)114 TransformArrayRef SubArray(size_type pos) {
115 return TransformArrayRef(base().subarray(pos), GetFunction());
116 }
SubArray(size_type pos)117 TransformArrayRef SubArray(size_type pos) const {
118 return TransformArrayRef(base().subarray(pos), GetFunction());
119 }
SubArray(size_type pos,size_type length)120 TransformArrayRef SubArray(size_type pos, size_type length) const {
121 return TransformArrayRef(base().subarray(pos, length), GetFunction());
122 }
123
124 // Retrieve the base ArrayRef<>.
base()125 ArrayRef<BaseType> base() {
126 return data_.base_;
127 }
base()128 ArrayRef<const BaseType> base() const {
129 return ArrayRef<const BaseType>(data_.base_);
130 }
131
132 private:
133 // Allow EBO for state-less Function.
134 struct Data : Function {
135 public:
DataData136 Data(ArrayRef<BaseType> base, Function fn) : Function(fn), base_(base) { }
137
138 ArrayRef<BaseType> base_;
139 };
140
GetFunction()141 const Function& GetFunction() const {
142 return static_cast<const Function&>(data_);
143 }
144
145 template <typename BaseIterator>
MakeIterator(BaseIterator base)146 auto MakeIterator(BaseIterator base) const {
147 return MakeTransformIterator(base, GetFunction());
148 }
149
150 Data data_;
151
152 template <typename OtherBT, typename OtherFunction>
153 friend class TransformArrayRef;
154 };
155
156 template <typename BaseType, typename Function>
157 bool operator==(const TransformArrayRef<BaseType, Function>& lhs,
158 const TransformArrayRef<BaseType, Function>& rhs) {
159 return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
160 }
161
162 template <typename BaseType, typename Function>
163 bool operator!=(const TransformArrayRef<BaseType, Function>& lhs,
164 const TransformArrayRef<BaseType, Function>& rhs) {
165 return !(lhs == rhs);
166 }
167
168 template <typename ValueType, typename Function>
MakeTransformArrayRef(ArrayRef<ValueType> container,Function f)169 TransformArrayRef<ValueType, Function> MakeTransformArrayRef(
170 ArrayRef<ValueType> container, Function f) {
171 return TransformArrayRef<ValueType, Function>(container, f);
172 }
173
174 template <typename Container, typename Function>
MakeTransformArrayRef(Container & container,Function f)175 TransformArrayRef<typename Container::value_type, Function> MakeTransformArrayRef(
176 Container& container, Function f) {
177 return TransformArrayRef<typename Container::value_type, Function>(
178 ArrayRef<typename Container::value_type>(container.data(), container.size()), f);
179 }
180
181 template <typename Container, typename Function>
MakeTransformArrayRef(const Container & container,Function f)182 TransformArrayRef<const typename Container::value_type, Function> MakeTransformArrayRef(
183 const Container& container, Function f) {
184 return TransformArrayRef<const typename Container::value_type, Function>(
185 ArrayRef<const typename Container::value_type>(container.data(), container.size()), f);
186 }
187
188 } // namespace art
189
190 #endif // ART_LIBARTBASE_BASE_TRANSFORM_ARRAY_REF_H_
191