|
|
|
// Copyright 2018 The Abseil Authors.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
//
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// File: fixed_array.h
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// A `FixedArray<T>` represents a non-resizable array of `T` where the length of
|
|
|
|
// the array can be determined at run-time. It is a good replacement for
|
|
|
|
// non-standard and deprecated uses of `alloca()` and variable length arrays
|
|
|
|
// within the GCC extension. (See
|
|
|
|
// https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html).
|
|
|
|
//
|
|
|
|
// `FixedArray` allocates small arrays inline, keeping performance fast by
|
|
|
|
// avoiding heap operations. It also helps reduce the chances of
|
|
|
|
// accidentally overflowing your stack if large input is passed to
|
|
|
|
// your function.
|
|
|
|
|
|
|
|
#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_
|
|
|
|
#define ABSL_CONTAINER_FIXED_ARRAY_H_
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <cassert>
|
|
|
|
#include <cstddef>
|
|
|
|
#include <initializer_list>
|
|
|
|
#include <iterator>
|
|
|
|
#include <limits>
|
|
|
|
#include <memory>
|
|
|
|
#include <new>
|
|
|
|
#include <type_traits>
|
|
|
|
|
|
|
|
#include "absl/algorithm/algorithm.h"
|
|
|
|
#include "absl/base/config.h"
|
|
|
|
#include "absl/base/dynamic_annotations.h"
|
|
|
|
#include "absl/base/internal/throw_delegate.h"
|
|
|
|
#include "absl/base/macros.h"
|
|
|
|
#include "absl/base/optimization.h"
|
|
|
|
#include "absl/base/port.h"
|
|
|
|
#include "absl/container/internal/compressed_tuple.h"
|
|
|
|
#include "absl/memory/memory.h"
|
|
|
|
|
|
|
|
namespace absl {
|
|
|
|
ABSL_NAMESPACE_BEGIN
|
|
|
|
|
|
|
|
constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// FixedArray
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// A `FixedArray` provides a run-time fixed-size array, allocating a small array
|
|
|
|
// inline for efficiency.
|
|
|
|
//
|
|
|
|
// Most users should not specify an `inline_elements` argument and let
|
|
|
|
// `FixedArray` automatically determine the number of elements
|
|
|
|
// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
|
|
|
|
// `FixedArray` implementation will use inline storage for arrays with a
|
|
|
|
// length <= `inline_elements`.
|
|
|
|
//
|
|
|
|
// Note that a `FixedArray` constructed with a `size_type` argument will
|
|
|
|
// default-initialize its values by leaving trivially constructible types
|
|
|
|
// uninitialized (e.g. int, int[4], double), and others default-constructed.
|
|
|
|
// This matches the behavior of c-style arrays and `std::array`, but not
|
|
|
|
// `std::vector`.
|
|
|
|
//
|
|
|
|
// Note that `FixedArray` does not provide a public allocator; if it requires a
|
|
|
|
// heap allocation, it will do so with global `::operator new[]()` and
|
|
|
|
// `::operator delete[]()`, even if T provides class-scope overrides for these
|
|
|
|
// operators.
|
|
|
|
template <typename T, size_t N = kFixedArrayUseDefault,
|
|
|
|
typename A = std::allocator<T>>
|
|
|
|
class FixedArray {
|
|
|
|
static_assert(!std::is_array<T>::value || std::extent<T>::value > 0,
|
|
|
|
"Arrays with unknown bounds cannot be used with FixedArray.");
|
|
|
|
|
|
|
|
static constexpr size_t kInlineBytesDefault = 256;
|
|
|
|
|
|
|
|
using AllocatorTraits = std::allocator_traits<A>;
|
|
|
|
// std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
|
|
|
|
// but this seems to be mostly pedantic.
|
|
|
|
template <typename Iterator>
|
|
|
|
using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
|
|
|
|
typename std::iterator_traits<Iterator>::iterator_category,
|
|
|
|
std::forward_iterator_tag>::value>;
|
|
|
|
static constexpr bool NoexceptCopyable() {
|
|
|
|
return std::is_nothrow_copy_constructible<StorageElement>::value &&
|
|
|
|
absl::allocator_is_nothrow<allocator_type>::value;
|
|
|
|
}
|
|
|
|
static constexpr bool NoexceptMovable() {
|
|
|
|
return std::is_nothrow_move_constructible<StorageElement>::value &&
|
|
|
|
absl::allocator_is_nothrow<allocator_type>::value;
|
|
|
|
}
|
|
|
|
static constexpr bool DefaultConstructorIsNonTrivial() {
|
|
|
|
return !absl::is_trivially_default_constructible<StorageElement>::value;
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
using allocator_type = typename AllocatorTraits::allocator_type;
|
|
|
|
using value_type = typename AllocatorTraits::value_type;
|
|
|
|
using pointer = typename AllocatorTraits::pointer;
|
|
|
|
using const_pointer = typename AllocatorTraits::const_pointer;
|
|
|
|
using reference = value_type&;
|
|
|
|
using const_reference = const value_type&;
|
|
|
|
using size_type = typename AllocatorTraits::size_type;
|
|
|
|
using difference_type = typename AllocatorTraits::difference_type;
|
|
|
|
using iterator = pointer;
|
|
|
|
using const_iterator = const_pointer;
|
|
|
|
using reverse_iterator = std::reverse_iterator<iterator>;
|
|
|
|
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
|
|
|
|
|
|
|
|
static constexpr size_type inline_elements =
|
|
|
|
(N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
|
|
|
|
: static_cast<size_type>(N));
|
|
|
|
|
|
|
|
FixedArray(
|
|
|
|
const FixedArray& other,
|
|
|
|
const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable())
|
|
|
|
: FixedArray(other.begin(), other.end(), a) {}
|
|
|
|
|
|
|
|
FixedArray(
|
|
|
|
FixedArray&& other,
|
|
|
|
const allocator_type& a = allocator_type()) noexcept(NoexceptMovable())
|
|
|
|
: FixedArray(std::make_move_iterator(other.begin()),
|
|
|
|
std::make_move_iterator(other.end()), a) {}
|
|
|
|
|
|
|
|
// Creates an array object that can store `n` elements.
|
|
|
|
// Note that trivially constructible elements will be uninitialized.
|
|
|
|
explicit FixedArray(size_type n, const allocator_type& a = allocator_type())
|
|
|
|
: storage_(n, a) {
|
|
|
|
if (DefaultConstructorIsNonTrivial()) {
|
|
|
|
memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
|
|
|
|
storage_.end());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates an array initialized with `n` copies of `val`.
|
|
|
|
FixedArray(size_type n, const value_type& val,
|
|
|
|
const allocator_type& a = allocator_type())
|
|
|
|
: storage_(n, a) {
|
|
|
|
memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
|
|
|
|
storage_.end(), val);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Creates an array initialized with the size and contents of `init_list`.
|
|
|
|
FixedArray(std::initializer_list<value_type> init_list,
|
|
|
|
const allocator_type& a = allocator_type())
|
|
|
|
: FixedArray(init_list.begin(), init_list.end(), a) {}
|
|
|
|
|
|
|
|
// Creates an array initialized with the elements from the input
|
|
|
|
// range. The array's size will always be `std::distance(first, last)`.
|
|
|
|
// REQUIRES: Iterator must be a forward_iterator or better.
|
|
|
|
template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
|
|
|
|
FixedArray(Iterator first, Iterator last,
|
|
|
|
const allocator_type& a = allocator_type())
|
|
|
|
: storage_(std::distance(first, last), a) {
|
|
|
|
memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last);
|
|
|
|
}
|
|
|
|
|
|
|
|
~FixedArray() noexcept {
|
|
|
|
for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
|
|
|
|
AllocatorTraits::destroy(storage_.alloc(), cur);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Assignments are deleted because they break the invariant that the size of a
|
|
|
|
// `FixedArray` never changes.
|
|
|
|
void operator=(FixedArray&&) = delete;
|
|
|
|
void operator=(const FixedArray&) = delete;
|
|
|
|
|
|
|
|
// FixedArray::size()
|
|
|
|
//
|
|
|
|
// Returns the length of the fixed array.
|
|
|
|
size_type size() const { return storage_.size(); }
|
|
|
|
|
|
|
|
// FixedArray::max_size()
|
|
|
|
//
|
|
|
|
// Returns the largest possible value of `std::distance(begin(), end())` for a
|
|
|
|
// `FixedArray<T>`. This is equivalent to the most possible addressable bytes
|
|
|
|
// over the number of bytes taken by T.
|
|
|
|
constexpr size_type max_size() const {
|
|
|
|
return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::empty()
|
|
|
|
//
|
|
|
|
// Returns whether or not the fixed array is empty.
|
|
|
|
bool empty() const { return size() == 0; }
|
|
|
|
|
|
|
|
// FixedArray::memsize()
|
|
|
|
//
|
|
|
|
// Returns the memory size of the fixed array in bytes.
|
|
|
|
size_t memsize() const { return size() * sizeof(value_type); }
|
|
|
|
|
|
|
|
// FixedArray::data()
|
|
|
|
//
|
|
|
|
// Returns a const T* pointer to elements of the `FixedArray`. This pointer
|
|
|
|
// can be used to access (but not modify) the contained elements.
|
|
|
|
const_pointer data() const { return AsValueType(storage_.begin()); }
|
|
|
|
|
|
|
|
// Overload of FixedArray::data() to return a T* pointer to elements of the
|
|
|
|
// fixed array. This pointer can be used to access and modify the contained
|
|
|
|
// elements.
|
|
|
|
pointer data() { return AsValueType(storage_.begin()); }
|
|
|
|
|
|
|
|
// FixedArray::operator[]
|
|
|
|
//
|
|
|
|
// Returns a reference the ith element of the fixed array.
|
|
|
|
// REQUIRES: 0 <= i < size()
|
|
|
|
reference operator[](size_type i) {
|
|
|
|
ABSL_HARDENING_ASSERT(i < size());
|
|
|
|
return data()[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overload of FixedArray::operator()[] to return a const reference to the
|
|
|
|
// ith element of the fixed array.
|
|
|
|
// REQUIRES: 0 <= i < size()
|
|
|
|
const_reference operator[](size_type i) const {
|
|
|
|
ABSL_HARDENING_ASSERT(i < size());
|
|
|
|
return data()[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::at
|
|
|
|
//
|
|
|
|
// Bounds-checked access. Returns a reference to the ith element of the
|
|
|
|
// fiexed array, or throws std::out_of_range
|
|
|
|
reference at(size_type i) {
|
|
|
|
if (ABSL_PREDICT_FALSE(i >= size())) {
|
|
|
|
base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
|
|
|
|
}
|
|
|
|
return data()[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overload of FixedArray::at() to return a const reference to the ith element
|
|
|
|
// of the fixed array.
|
|
|
|
const_reference at(size_type i) const {
|
|
|
|
if (ABSL_PREDICT_FALSE(i >= size())) {
|
|
|
|
base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
|
|
|
|
}
|
|
|
|
return data()[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::front()
|
|
|
|
//
|
|
|
|
// Returns a reference to the first element of the fixed array.
|
|
|
|
reference front() {
|
|
|
|
ABSL_HARDENING_ASSERT(!empty());
|
|
|
|
return data()[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overload of FixedArray::front() to return a reference to the first element
|
|
|
|
// of a fixed array of const values.
|
|
|
|
const_reference front() const {
|
|
|
|
ABSL_HARDENING_ASSERT(!empty());
|
|
|
|
return data()[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::back()
|
|
|
|
//
|
|
|
|
// Returns a reference to the last element of the fixed array.
|
|
|
|
reference back() {
|
|
|
|
ABSL_HARDENING_ASSERT(!empty());
|
|
|
|
return data()[size() - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Overload of FixedArray::back() to return a reference to the last element
|
|
|
|
// of a fixed array of const values.
|
|
|
|
const_reference back() const {
|
|
|
|
ABSL_HARDENING_ASSERT(!empty());
|
|
|
|
return data()[size() - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::begin()
|
|
|
|
//
|
|
|
|
// Returns an iterator to the beginning of the fixed array.
|
|
|
|
iterator begin() { return data(); }
|
|
|
|
|
|
|
|
// Overload of FixedArray::begin() to return a const iterator to the
|
|
|
|
// beginning of the fixed array.
|
|
|
|
const_iterator begin() const { return data(); }
|
|
|
|
|
|
|
|
// FixedArray::cbegin()
|
|
|
|
//
|
|
|
|
// Returns a const iterator to the beginning of the fixed array.
|
|
|
|
const_iterator cbegin() const { return begin(); }
|
|
|
|
|
|
|
|
// FixedArray::end()
|
|
|
|
//
|
|
|
|
// Returns an iterator to the end of the fixed array.
|
|
|
|
iterator end() { return data() + size(); }
|
|
|
|
|
|
|
|
// Overload of FixedArray::end() to return a const iterator to the end of the
|
|
|
|
// fixed array.
|
|
|
|
const_iterator end() const { return data() + size(); }
|
|
|
|
|
|
|
|
// FixedArray::cend()
|
|
|
|
//
|
|
|
|
// Returns a const iterator to the end of the fixed array.
|
|
|
|
const_iterator cend() const { return end(); }
|
|
|
|
|
|
|
|
// FixedArray::rbegin()
|
|
|
|
//
|
|
|
|
// Returns a reverse iterator from the end of the fixed array.
|
|
|
|
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
|
|
|
|
|
|
|
// Overload of FixedArray::rbegin() to return a const reverse iterator from
|
|
|
|
// the end of the fixed array.
|
|
|
|
const_reverse_iterator rbegin() const {
|
|
|
|
return const_reverse_iterator(end());
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::crbegin()
|
|
|
|
//
|
|
|
|
// Returns a const reverse iterator from the end of the fixed array.
|
|
|
|
const_reverse_iterator crbegin() const { return rbegin(); }
|
|
|
|
|
|
|
|
// FixedArray::rend()
|
|
|
|
//
|
|
|
|
// Returns a reverse iterator from the beginning of the fixed array.
|
|
|
|
reverse_iterator rend() { return reverse_iterator(begin()); }
|
|
|
|
|
|
|
|
// Overload of FixedArray::rend() for returning a const reverse iterator
|
|
|
|
// from the beginning of the fixed array.
|
|
|
|
const_reverse_iterator rend() const {
|
|
|
|
return const_reverse_iterator(begin());
|
|
|
|
}
|
|
|
|
|
|
|
|
// FixedArray::crend()
|
|
|
|
//
|
|
|
|
// Returns a reverse iterator from the beginning of the fixed array.
|
|
|
|
const_reverse_iterator crend() const { return rend(); }
|
|
|
|
|
|
|
|
// FixedArray::fill()
|
|
|
|
//
|
|
|
|
// Assigns the given `value` to all elements in the fixed array.
|
|
|
|
void fill(const value_type& val) { std::fill(begin(), end(), val); }
|
|
|
|
|
|
|
|
// Relational operators. Equality operators are elementwise using
|
|
|
|
// `operator==`, while order operators order FixedArrays lexicographically.
|
|
|
|
friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return !(lhs == rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
|
|
|
|
rhs.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return rhs < lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return !(rhs < lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
|
|
|
|
return !(lhs < rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename H>
|
|
|
|
friend H AbslHashValue(H h, const FixedArray& v) {
|
|
|
|
return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
|
|
|
|
v.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// StorageElement
|
|
|
|
//
|
|
|
|
// For FixedArrays with a C-style-array value_type, StorageElement is a POD
|
|
|
|
// wrapper struct called StorageElementWrapper that holds the value_type
|
|
|
|
// instance inside. This is needed for construction and destruction of the
|
|
|
|
// entire array regardless of how many dimensions it has. For all other cases,
|
|
|
|
// StorageElement is just an alias of value_type.
|
|
|
|
//
|
|
|
|
// Maintainer's Note: The simpler solution would be to simply wrap value_type
|
|
|
|
// in a struct whether it's an array or not. That causes some paranoid
|
|
|
|
// diagnostics to misfire, believing that 'data()' returns a pointer to a
|
|
|
|
// single element, rather than the packed array that it really is.
|
|
|
|
// e.g.:
|
|
|
|
//
|
|
|
|
// FixedArray<char> buf(1);
|
|
|
|
// sprintf(buf.data(), "foo");
|
|
|
|
//
|
|
|
|
// error: call to int __builtin___sprintf_chk(etc...)
|
|
|
|
// will always overflow destination buffer [-Werror]
|
|
|
|
//
|
|
|
|
template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>,
|
|
|
|
size_t InnerN = std::extent<OuterT>::value>
|
|
|
|
struct StorageElementWrapper {
|
|
|
|
InnerT array[InnerN];
|
|
|
|
};
|
|
|
|
|
|
|
|
using StorageElement =
|
|
|
|
absl::conditional_t<std::is_array<value_type>::value,
|
|
|
|
StorageElementWrapper<value_type>, value_type>;
|
|
|
|
|
|
|
|
static pointer AsValueType(pointer ptr) { return ptr; }
|
|
|
|
static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
|
|
|
|
return std::addressof(ptr->array);
|
|
|
|
}
|
|
|
|
|
|
|
|
static_assert(sizeof(StorageElement) == sizeof(value_type), "");
|
|
|
|
static_assert(alignof(StorageElement) == alignof(value_type), "");
|
|
|
|
|
|
|
|
class NonEmptyInlinedStorage {
|
|
|
|
public:
|
|
|
|
StorageElement* data() { return reinterpret_cast<StorageElement*>(buff_); }
|
|
|
|
void AnnotateConstruct(size_type n);
|
|
|
|
void AnnotateDestruct(size_type n);
|
|
|
|
|
|
|
|
#ifdef ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
void* RedzoneBegin() { return &redzone_begin_; }
|
|
|
|
void* RedzoneEnd() { return &redzone_end_ + 1; }
|
|
|
|
#endif // ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
|
|
|
|
private:
|
|
|
|
ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
|
|
|
|
alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
|
|
|
|
ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
|
|
|
|
};
|
|
|
|
|
|
|
|
class EmptyInlinedStorage {
|
|
|
|
public:
|
|
|
|
StorageElement* data() { return nullptr; }
|
|
|
|
void AnnotateConstruct(size_type) {}
|
|
|
|
void AnnotateDestruct(size_type) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
using InlinedStorage =
|
|
|
|
absl::conditional_t<inline_elements == 0, EmptyInlinedStorage,
|
|
|
|
NonEmptyInlinedStorage>;
|
|
|
|
|
|
|
|
// Storage
|
|
|
|
//
|
|
|
|
// An instance of Storage manages the inline and out-of-line memory for
|
|
|
|
// instances of FixedArray. This guarantees that even when construction of
|
|
|
|
// individual elements fails in the FixedArray constructor body, the
|
|
|
|
// destructor for Storage will still be called and out-of-line memory will be
|
|
|
|
// properly deallocated.
|
|
|
|
//
|
|
|
|
class Storage : public InlinedStorage {
|
|
|
|
public:
|
|
|
|
Storage(size_type n, const allocator_type& a)
|
|
|
|
: size_alloc_(n, a), data_(InitializeData()) {}
|
|
|
|
|
|
|
|
~Storage() noexcept {
|
|
|
|
if (UsingInlinedStorage(size())) {
|
|
|
|
InlinedStorage::AnnotateDestruct(size());
|
|
|
|
} else {
|
|
|
|
AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
size_type size() const { return size_alloc_.template get<0>(); }
|
|
|
|
StorageElement* begin() const { return data_; }
|
|
|
|
StorageElement* end() const { return begin() + size(); }
|
|
|
|
allocator_type& alloc() { return size_alloc_.template get<1>(); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
static bool UsingInlinedStorage(size_type n) {
|
|
|
|
return n <= inline_elements;
|
|
|
|
}
|
|
|
|
|
|
|
|
StorageElement* InitializeData() {
|
|
|
|
if (UsingInlinedStorage(size())) {
|
|
|
|
InlinedStorage::AnnotateConstruct(size());
|
|
|
|
return InlinedStorage::data();
|
|
|
|
} else {
|
|
|
|
return reinterpret_cast<StorageElement*>(
|
|
|
|
AllocatorTraits::allocate(alloc(), size()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
|
|
|
|
container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
|
|
|
|
StorageElement* data_;
|
|
|
|
};
|
|
|
|
|
|
|
|
Storage storage_;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, size_t N, typename A>
|
|
|
|
constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
|
|
|
|
|
|
|
|
template <typename T, size_t N, typename A>
|
|
|
|
constexpr typename FixedArray<T, N, A>::size_type
|
|
|
|
FixedArray<T, N, A>::inline_elements;
|
|
|
|
|
|
|
|
template <typename T, size_t N, typename A>
|
|
|
|
void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
|
|
|
|
typename FixedArray<T, N, A>::size_type n) {
|
|
|
|
#ifdef ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
if (!n) return;
|
|
|
|
ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
|
|
|
|
data() + n);
|
|
|
|
ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
|
|
|
|
RedzoneBegin());
|
|
|
|
#endif // ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
static_cast<void>(n); // Mark used when not in asan mode
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, size_t N, typename A>
|
|
|
|
void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
|
|
|
|
typename FixedArray<T, N, A>::size_type n) {
|
|
|
|
#ifdef ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
if (!n) return;
|
|
|
|
ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
|
|
|
|
RedzoneEnd());
|
|
|
|
ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
|
|
|
|
data());
|
|
|
|
#endif // ABSL_HAVE_ADDRESS_SANITIZER
|
|
|
|
static_cast<void>(n); // Mark used when not in asan mode
|
|
|
|
}
|
|
|
|
ABSL_NAMESPACE_END
|
|
|
|
} // namespace absl
|
|
|
|
|
|
|
|
#endif // ABSL_CONTAINER_FIXED_ARRAY_H_
|