blob: 03587e35ac7026887180efff9289a731f919ea7c [file] [log] [blame]
Dominik Laskowski0bacf272020-10-22 14:08:27 -07001/*
2 * Copyright 2020 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#pragma once
18
Dominik Laskowski04667b72021-12-15 13:14:54 -080019#include <ftl/details/array_traits.h>
Dominik Laskowski5444fc82020-11-24 13:41:10 -080020#include <ftl/static_vector.h>
Dominik Laskowski0bacf272020-10-22 14:08:27 -070021
22#include <algorithm>
23#include <iterator>
24#include <type_traits>
25#include <utility>
26#include <variant>
27#include <vector>
28
29namespace android::ftl {
30
31template <typename>
Dominik Laskowski5444fc82020-11-24 13:41:10 -080032struct is_small_vector;
Dominik Laskowski0bacf272020-10-22 14:08:27 -070033
34// ftl::StaticVector that promotes to std::vector when full. SmallVector is a drop-in replacement
35// for std::vector with statically allocated storage for N elements, whose goal is to improve run
36// time by avoiding heap allocation and increasing probability of cache hits. The standard API is
37// augmented by an unstable_erase operation that does not preserve order, and a replace operation
38// that destructively emplaces.
39//
40// SmallVector<T, 0> is a specialization that thinly wraps std::vector.
41//
42// Example usage:
43//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080044// ftl::SmallVector<char, 3> vector;
45// assert(vector.empty());
46// assert(!vector.dynamic());
Dominik Laskowski0bacf272020-10-22 14:08:27 -070047//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080048// vector = {'a', 'b', 'c'};
49// assert(vector.size() == 3u);
50// assert(!vector.dynamic());
Dominik Laskowski0bacf272020-10-22 14:08:27 -070051//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080052// vector.push_back('d');
53// assert(vector.dynamic());
Dominik Laskowski0bacf272020-10-22 14:08:27 -070054//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080055// vector.unstable_erase(vector.begin());
56// assert(vector == (ftl::SmallVector{'d', 'b', 'c'}));
Dominik Laskowski0bacf272020-10-22 14:08:27 -070057//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080058// vector.pop_back();
59// assert(vector.back() == 'b');
60// assert(vector.dynamic());
Dominik Laskowski0bacf272020-10-22 14:08:27 -070061//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080062// const char array[] = "hi";
63// vector = ftl::SmallVector(array);
64// assert(vector == (ftl::SmallVector{'h', 'i', '\0'}));
65// assert(!vector.dynamic());
Dominik Laskowski0bacf272020-10-22 14:08:27 -070066//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080067// ftl::SmallVector strings = ftl::init::list<std::string>("abc")("123456", 3u)(3u, '?');
68// assert(strings.size() == 3u);
69// assert(!strings.dynamic());
Dominik Laskowskiccd50a42020-10-30 19:56:38 -070070//
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080071// assert(strings[0] == "abc");
72// assert(strings[1] == "123");
73// assert(strings[2] == "???");
Dominik Laskowskiccd50a42020-10-30 19:56:38 -070074//
Dominik Laskowski5444fc82020-11-24 13:41:10 -080075template <typename T, std::size_t N>
Dominik Laskowski04667b72021-12-15 13:14:54 -080076class SmallVector final : details::ArrayTraits<T>, details::ArrayComparators<SmallVector> {
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080077 using Static = StaticVector<T, N>;
78 using Dynamic = SmallVector<T, 0>;
Dominik Laskowski0bacf272020-10-22 14:08:27 -070079
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080080 // TODO: Replace with std::remove_cvref_t in C++20.
81 template <typename U>
82 using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<U>>;
Dominik Laskowski0bacf272020-10-22 14:08:27 -070083
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080084 public:
85 FTL_ARRAY_TRAIT(T, value_type);
86 FTL_ARRAY_TRAIT(T, size_type);
87 FTL_ARRAY_TRAIT(T, difference_type);
Dominik Laskowski0bacf272020-10-22 14:08:27 -070088
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080089 FTL_ARRAY_TRAIT(T, pointer);
90 FTL_ARRAY_TRAIT(T, reference);
91 FTL_ARRAY_TRAIT(T, iterator);
92 FTL_ARRAY_TRAIT(T, reverse_iterator);
Dominik Laskowski0bacf272020-10-22 14:08:27 -070093
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080094 FTL_ARRAY_TRAIT(T, const_pointer);
95 FTL_ARRAY_TRAIT(T, const_reference);
96 FTL_ARRAY_TRAIT(T, const_iterator);
97 FTL_ARRAY_TRAIT(T, const_reverse_iterator);
Dominik Laskowski0bacf272020-10-22 14:08:27 -070098
Dominik Laskowskie21dbed2020-12-04 20:51:43 -080099 // Creates an empty vector.
100 SmallVector() = default;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700101
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800102 // Constructs at most N elements. See StaticVector for underlying constructors.
103 template <typename Arg, typename... Args,
104 typename = std::enable_if_t<!is_small_vector<remove_cvref_t<Arg>>{}>>
105 SmallVector(Arg&& arg, Args&&... args)
106 : vector_(std::in_place_type<Static>, std::forward<Arg>(arg), std::forward<Args>(args)...) {}
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700107
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800108 // Copies at most N elements from a smaller convertible vector.
109 template <typename U, std::size_t M, typename = std::enable_if_t<M <= N>>
110 SmallVector(const SmallVector<U, M>& other)
111 : SmallVector(kIteratorRange, other.begin(), other.end()) {}
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700112
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800113 void swap(SmallVector& other) { vector_.swap(other.vector_); }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700114
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800115 // Returns whether the vector is backed by static or dynamic storage.
116 bool dynamic() const { return std::holds_alternative<Dynamic>(vector_); }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700117
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800118 // Avoid std::visit as it generates a dispatch table.
119#define DISPATCH(T, F, ...) \
120 T F() __VA_ARGS__ { \
121 return dynamic() ? std::get<Dynamic>(vector_).F() : std::get<Static>(vector_).F(); \
122 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700123
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800124 DISPATCH(size_type, max_size, const)
125 DISPATCH(size_type, size, const)
126 DISPATCH(bool, empty, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700127
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800128 // noexcept to suppress warning about zero variadic macro arguments.
129 DISPATCH(iterator, begin, noexcept)
130 DISPATCH(const_iterator, begin, const)
131 DISPATCH(const_iterator, cbegin, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700132
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800133 DISPATCH(iterator, end, noexcept)
134 DISPATCH(const_iterator, end, const)
135 DISPATCH(const_iterator, cend, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700136
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800137 DISPATCH(reverse_iterator, rbegin, noexcept)
138 DISPATCH(const_reverse_iterator, rbegin, const)
139 DISPATCH(const_reverse_iterator, crbegin, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700140
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800141 DISPATCH(reverse_iterator, rend, noexcept)
142 DISPATCH(const_reverse_iterator, rend, const)
143 DISPATCH(const_reverse_iterator, crend, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700144
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800145 DISPATCH(iterator, last, noexcept)
146 DISPATCH(const_iterator, last, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700147
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800148 DISPATCH(reference, front, noexcept)
149 DISPATCH(const_reference, front, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700150
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800151 DISPATCH(reference, back, noexcept)
152 DISPATCH(const_reference, back, const)
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700153
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800154 reference operator[](size_type i) {
155 return dynamic() ? std::get<Dynamic>(vector_)[i] : std::get<Static>(vector_)[i];
156 }
157
158 const_reference operator[](size_type i) const { return const_cast<SmallVector&>(*this)[i]; }
159
160 // Replaces an element, and returns a reference to it. The iterator must be dereferenceable, so
161 // replacing at end() is erroneous.
162 //
163 // The element is emplaced via move constructor, so type T does not need to define copy/move
164 // assignment, e.g. its data members may be const.
165 //
166 // The arguments may directly or indirectly refer to the element being replaced.
167 //
168 // Iterators to the replaced element point to its replacement, and others remain valid.
169 //
170 template <typename... Args>
171 reference replace(const_iterator it, Args&&... args) {
172 if (dynamic()) {
173 return std::get<Dynamic>(vector_).replace(it, std::forward<Args>(args)...);
174 } else {
175 return std::get<Static>(vector_).replace(it, std::forward<Args>(args)...);
176 }
177 }
178
179 // Appends an element, and returns a reference to it.
180 //
181 // If the vector reaches its static or dynamic capacity, then all iterators are invalidated.
182 // Otherwise, only the end() iterator is invalidated.
183 //
184 template <typename... Args>
185 reference emplace_back(Args&&... args) {
186 constexpr auto kInsertStatic = &Static::template emplace_back<Args...>;
187 constexpr auto kInsertDynamic = &Dynamic::template emplace_back<Args...>;
188 return *insert<kInsertStatic, kInsertDynamic>(std::forward<Args>(args)...);
189 }
190
191 // Appends an element.
192 //
193 // If the vector reaches its static or dynamic capacity, then all iterators are invalidated.
194 // Otherwise, only the end() iterator is invalidated.
195 //
196 void push_back(const value_type& v) {
197 constexpr auto kInsertStatic =
198 static_cast<bool (Static::*)(const value_type&)>(&Static::push_back);
199 constexpr auto kInsertDynamic =
200 static_cast<bool (Dynamic::*)(const value_type&)>(&Dynamic::push_back);
201 insert<kInsertStatic, kInsertDynamic>(v);
202 }
203
204 void push_back(value_type&& v) {
205 constexpr auto kInsertStatic = static_cast<bool (Static::*)(value_type &&)>(&Static::push_back);
206 constexpr auto kInsertDynamic =
207 static_cast<bool (Dynamic::*)(value_type &&)>(&Dynamic::push_back);
208 insert<kInsertStatic, kInsertDynamic>(std::move(v));
209 }
210
211 // Removes the last element. The vector must not be empty, or the call is erroneous.
212 //
213 // The last() and end() iterators are invalidated.
214 //
Dominik Laskowski44828ce2021-09-13 11:00:22 -0700215 DISPATCH(void, pop_back, noexcept)
216
217 // Removes all elements.
218 //
219 // All iterators are invalidated.
220 //
221 DISPATCH(void, clear, noexcept)
222
223#undef DISPATCH
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800224
225 // Erases an element, but does not preserve order. Rather than shifting subsequent elements,
226 // this moves the last element to the slot of the erased element.
227 //
228 // The last() and end() iterators, as well as those to the erased element, are invalidated.
229 //
230 void unstable_erase(iterator it) {
231 if (dynamic()) {
232 std::get<Dynamic>(vector_).unstable_erase(it);
233 } else {
234 std::get<Static>(vector_).unstable_erase(it);
235 }
236 }
237
238 private:
239 template <auto InsertStatic, auto InsertDynamic, typename... Args>
240 auto insert(Args&&... args) {
241 if (Dynamic* const vector = std::get_if<Dynamic>(&vector_)) {
242 return (vector->*InsertDynamic)(std::forward<Args>(args)...);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700243 }
244
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800245 auto& vector = std::get<Static>(vector_);
246 if (vector.full()) {
247 return (promote(vector).*InsertDynamic)(std::forward<Args>(args)...);
248 } else {
249 return (vector.*InsertStatic)(std::forward<Args>(args)...);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700250 }
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800251 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700252
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800253 Dynamic& promote(Static& static_vector) {
254 assert(static_vector.full());
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700255
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800256 // Allocate double capacity to reduce probability of reallocation.
257 Dynamic vector;
258 vector.reserve(Static::max_size() * 2);
259 std::move(static_vector.begin(), static_vector.end(), std::back_inserter(vector));
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700260
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800261 return vector_.template emplace<Dynamic>(std::move(vector));
262 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700263
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800264 std::variant<Static, Dynamic> vector_;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700265};
266
267// Partial specialization without static storage.
268template <typename T>
Dominik Laskowski04667b72021-12-15 13:14:54 -0800269class SmallVector<T, 0> final : details::ArrayTraits<T>,
270 details::ArrayIterators<SmallVector<T, 0>, T>,
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700271 std::vector<T> {
Dominik Laskowski04667b72021-12-15 13:14:54 -0800272 using details::ArrayTraits<T>::construct_at;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700273
Dominik Laskowski04667b72021-12-15 13:14:54 -0800274 using Iter = details::ArrayIterators<SmallVector, T>;
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800275 using Impl = std::vector<T>;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700276
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800277 friend Iter;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700278
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800279 public:
280 FTL_ARRAY_TRAIT(T, value_type);
281 FTL_ARRAY_TRAIT(T, size_type);
282 FTL_ARRAY_TRAIT(T, difference_type);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700283
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800284 FTL_ARRAY_TRAIT(T, pointer);
285 FTL_ARRAY_TRAIT(T, reference);
286 FTL_ARRAY_TRAIT(T, iterator);
287 FTL_ARRAY_TRAIT(T, reverse_iterator);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700288
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800289 FTL_ARRAY_TRAIT(T, const_pointer);
290 FTL_ARRAY_TRAIT(T, const_reference);
291 FTL_ARRAY_TRAIT(T, const_iterator);
292 FTL_ARRAY_TRAIT(T, const_reverse_iterator);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700293
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800294 using Impl::Impl;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700295
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800296 using Impl::empty;
297 using Impl::max_size;
298 using Impl::size;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700299
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800300 using Impl::reserve;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700301
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800302 // std::vector iterators are not necessarily raw pointers.
303 iterator begin() { return Impl::data(); }
304 iterator end() { return Impl::data() + size(); }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700305
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800306 using Iter::begin;
307 using Iter::end;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700308
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800309 using Iter::cbegin;
310 using Iter::cend;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700311
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800312 using Iter::rbegin;
313 using Iter::rend;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700314
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800315 using Iter::crbegin;
316 using Iter::crend;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700317
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800318 using Iter::last;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700319
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800320 using Iter::back;
321 using Iter::front;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700322
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800323 using Iter::operator[];
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700324
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800325 template <typename... Args>
326 reference replace(const_iterator it, Args&&... args) {
327 value_type element{std::forward<Args>(args)...};
328 std::destroy_at(it);
329 // This is only safe because exceptions are disabled.
330 return *construct_at(it, std::move(element));
331 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700332
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800333 template <typename... Args>
334 iterator emplace_back(Args&&... args) {
335 return &Impl::emplace_back(std::forward<Args>(args)...);
336 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700337
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800338 bool push_back(const value_type& v) {
339 Impl::push_back(v);
340 return true;
341 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700342
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800343 bool push_back(value_type&& v) {
344 Impl::push_back(std::move(v));
345 return true;
346 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700347
Dominik Laskowski44828ce2021-09-13 11:00:22 -0700348 using Impl::clear;
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800349 using Impl::pop_back;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700350
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800351 void unstable_erase(iterator it) {
Dominik Laskowskidda9bba2021-02-03 18:56:00 -0800352 if (it != last()) replace(it, std::move(back()));
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800353 pop_back();
354 }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700355
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800356 void swap(SmallVector& other) { Impl::swap(other); }
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700357};
358
359template <typename>
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800360struct is_small_vector : std::false_type {};
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700361
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800362template <typename T, std::size_t N>
363struct is_small_vector<SmallVector<T, N>> : std::true_type {};
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700364
365// Deduction guide for array constructor.
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800366template <typename T, std::size_t N>
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700367SmallVector(T (&)[N]) -> SmallVector<std::remove_cv_t<T>, N>;
368
369// Deduction guide for variadic constructor.
370template <typename T, typename... Us, typename V = std::decay_t<T>,
371 typename = std::enable_if_t<(std::is_constructible_v<V, Us> && ...)>>
372SmallVector(T&&, Us&&...) -> SmallVector<V, 1 + sizeof...(Us)>;
373
374// Deduction guide for in-place constructor.
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800375template <typename T, std::size_t... Sizes, typename... Types>
Dominik Laskowskiccd50a42020-10-30 19:56:38 -0700376SmallVector(InitializerList<T, std::index_sequence<Sizes...>, Types...>&&)
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800377 -> SmallVector<T, sizeof...(Sizes)>;
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700378
379// Deduction guide for StaticVector conversion.
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800380template <typename T, std::size_t N>
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700381SmallVector(StaticVector<T, N>&&) -> SmallVector<T, N>;
382
Dominik Laskowski5444fc82020-11-24 13:41:10 -0800383template <typename T, std::size_t N>
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700384inline void swap(SmallVector<T, N>& lhs, SmallVector<T, N>& rhs) {
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800385 lhs.swap(rhs);
Dominik Laskowski0bacf272020-10-22 14:08:27 -0700386}
387
Dominik Laskowskie21dbed2020-12-04 20:51:43 -0800388} // namespace android::ftl