mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
1edfe05ddddca43e7650b2d790df7c8498c0e588 by Abseil Team <absl-team@google.com>:

Adding an assert to catch various misuses of std::optional.

PiperOrigin-RevId: 249427865

--
45463bbb7e59dfbc584b2f024368a63db98bd7a8 by CJ Johnson <johnsoncj@google.com>:

Migrates internal member function GetAllocator() to GetAllocPtr() and changes the return type to pointer instead of reference to avoid unnecessary copy in DestroyElements(...)

PiperOrigin-RevId: 249319571

--
507835be22af85676143ee0c43a80a52bc32094c by Abseil Team <absl-team@google.com>:

Fix -Wstring-conversion in GetEnvVar (Windows implementation).

PiperOrigin-RevId: 249201897
GitOrigin-RevId: 1edfe05ddddca43e7650b2d790df7c8498c0e588
Change-Id: I9300131887ee507cf80d399c724cf87341e4f11a
This commit is contained in:
Abseil Team 2019-05-22 05:06:50 -07:00 committed by Derek Mauro
parent a18fc7461e
commit ce65f5ac3c
4 changed files with 31 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
absl/container/inlined_vector.h
View file

@ -155,7 +155,7 @@ class InlinedVector {
// Creates a copy of an `other` inlined vector using `other`'s allocator.
InlinedVector(const InlinedVector& other)
: InlinedVector(other, other.storage_.GetAllocator()) {}
: InlinedVector(other, *other.storage_.GetAllocPtr()) {}
// Creates a copy of an `other` inlined vector using a specified allocator.
InlinedVector(const InlinedVector& other, const allocator_type& alloc)
@ -189,7 +189,7 @@ class InlinedVector {
InlinedVector(InlinedVector&& other) noexcept(
absl::allocator_is_nothrow<allocator_type>::value ||
std::is_nothrow_move_constructible<value_type>::value)
: storage_(other.storage_.GetAllocator()) {
: storage_(*other.storage_.GetAllocPtr()) {
if (other.storage_.GetIsAllocated()) {
// We can just steal the underlying buffer from the source.
// That leaves the source empty, so we clear its size.
@ -224,7 +224,7 @@ class InlinedVector {
absl::allocator_is_nothrow<allocator_type>::value)
: storage_(alloc) {
if (other.storage_.GetIsAllocated()) {
if (alloc == other.storage_.GetAllocator()) {
if (*storage_.GetAllocPtr() == *other.storage_.GetAllocPtr()) {
// We can just steal the allocation from the source.
storage_.SetAllocatedSize(other.size());
storage_.SetAllocatedData(other.storage_.GetAllocatedData());
@ -437,7 +437,7 @@ class InlinedVector {
// `InlinedVector::get_allocator()`
//
// Returns a copy of the allocator of the inlined vector.
allocator_type get_allocator() const { return storage_.GetAllocator(); }
allocator_type get_allocator() const { return *storage_.GetAllocPtr(); }
// ---------------------------------------------------------------------------
// InlinedVector Member Mutators
@ -794,19 +794,15 @@ class InlinedVector {
// deallocates the heap allocation if the inlined vector was allocated.
void clear() noexcept {
const bool is_allocated = storage_.GetIsAllocated();
pointer the_data =
is_allocated ? storage_.GetAllocatedData() : storage_.GetInlinedData();
inlined_vector_internal::DestroyElements(storage_.GetAllocator(), the_data,
inlined_vector_internal::DestroyElements(storage_.GetAllocPtr(), the_data,
storage_.GetSize());
storage_.SetInlinedSize(0);
if (is_allocated) {
AllocatorTraits::deallocate(storage_.GetAllocator(), the_data,
AllocatorTraits::deallocate(*storage_.GetAllocPtr(), the_data,
storage_.GetAllocatedCapacity());
}
storage_.SetInlinedSize(/* size = */ 0);
}
// `InlinedVector::reserve()`
@ -854,7 +850,7 @@ class InlinedVector {
// Reallocate storage and move elements.
// We can't simply use the same approach as above, because `assign()` would
// call into `reserve()` internally and reserve larger capacity than we need
pointer new_data = AllocatorTraits::allocate(storage_.GetAllocator(), s);
pointer new_data = AllocatorTraits::allocate(*storage_.GetAllocPtr(), s);
UninitializedCopy(std::make_move_iterator(storage_.GetAllocatedData()),
std::make_move_iterator(storage_.GetAllocatedData() + s),
new_data);
@ -880,7 +876,7 @@ class InlinedVector {
Destroy(storage_.GetAllocatedData(),
storage_.GetAllocatedData() + size());
assert(begin() == storage_.GetAllocatedData());
AllocatorTraits::deallocate(storage_.GetAllocator(),
AllocatorTraits::deallocate(*storage_.GetAllocPtr(),
storage_.GetAllocatedData(),
storage_.GetAllocatedCapacity());
} else {
@ -895,7 +891,7 @@ class InlinedVector {
template <typename... Args>
reference Construct(pointer p, Args&&... args) {
std::allocator_traits<allocator_type>::construct(
storage_.GetAllocator(), p, std::forward<Args>(args)...);
*storage_.GetAllocPtr(), p, std::forward<Args>(args)...);
return *p;
}
@ -912,7 +908,7 @@ class InlinedVector {
// Destroy [`from`, `to`) in place.
void Destroy(pointer from, pointer to) {
for (pointer cur = from; cur != to; ++cur) {
std::allocator_traits<allocator_type>::destroy(storage_.GetAllocator(),
std::allocator_traits<allocator_type>::destroy(*storage_.GetAllocPtr(),
cur);
}
#if !defined(NDEBUG)
@ -943,7 +939,7 @@ class InlinedVector {
}
pointer new_data =
AllocatorTraits::allocate(storage_.GetAllocator(), new_capacity);
AllocatorTraits::allocate(*storage_.GetAllocPtr(), new_capacity);
UninitializedCopy(std::make_move_iterator(data()),
std::make_move_iterator(data() + s), new_data);
@ -975,7 +971,7 @@ class InlinedVector {
// Move everyone into the new allocation, leaving a gap of `n` for the
// requested shift.
pointer new_data =
AllocatorTraits::allocate(storage_.GetAllocator(), new_capacity);
AllocatorTraits::allocate(*storage_.GetAllocPtr(), new_capacity);
size_type index = position - begin();
UninitializedCopy(std::make_move_iterator(data()),
std::make_move_iterator(data() + index), new_data);
@ -1024,7 +1020,7 @@ class InlinedVector {
size_type new_capacity = 2 * capacity();
pointer new_data =
AllocatorTraits::allocate(storage_.GetAllocator(), new_capacity);
AllocatorTraits::allocate(*storage_.GetAllocPtr(), new_capacity);
reference new_element =
Construct(new_data + s, std::forward<Args>(args)...);
@ -1038,7 +1034,7 @@ class InlinedVector {
void InitAssign(size_type n) {
if (n > static_cast<size_type>(N)) {
pointer new_data = AllocatorTraits::allocate(storage_.GetAllocator(), n);
pointer new_data = AllocatorTraits::allocate(*storage_.GetAllocPtr(), n);
storage_.SetAllocatedData(new_data);
storage_.SetAllocatedCapacity(n);
UninitializedFill(storage_.GetAllocatedData(),
@ -1053,7 +1049,7 @@ class InlinedVector {
void InitAssign(size_type n, const_reference v) {
if (n > static_cast<size_type>(N)) {
pointer new_data = AllocatorTraits::allocate(storage_.GetAllocator(), n);
pointer new_data = AllocatorTraits::allocate(*storage_.GetAllocPtr(), n);
storage_.SetAllocatedData(new_data);
storage_.SetAllocatedCapacity(n);
UninitializedFill(storage_.GetAllocatedData(),
@ -1126,7 +1122,7 @@ class InlinedVector {
// Both out of line, so just swap the tag, allocation, and allocator.
storage_.SwapSizeAndIsAllocated(std::addressof(other.storage_));
storage_.SwapAllocatedSizeAndCapacity(std::addressof(other.storage_));
swap(storage_.GetAllocator(), other.storage_.GetAllocator());
swap(*storage_.GetAllocPtr(), *other.storage_.GetAllocPtr());
return;
}
@ -1156,7 +1152,7 @@ class InlinedVector {
a->storage_.GetInlinedData() + a_size);
storage_.SwapSizeAndIsAllocated(std::addressof(other.storage_));
swap(storage_.GetAllocator(), other.storage_.GetAllocator());
swap(*storage_.GetAllocPtr(), *other.storage_.GetAllocPtr());
assert(b->size() == a_size);
assert(a->size() == b_size);
@ -1198,8 +1194,8 @@ class InlinedVector {
a->storage_.SetAllocatedData(b_data);
a->storage_.SetAllocatedCapacity(b_capacity);
if (a->storage_.GetAllocator() != b->storage_.GetAllocator()) {
swap(a->storage_.GetAllocator(), b->storage_.GetAllocator());
if (*a->storage_.GetAllocPtr() != *b->storage_.GetAllocPtr()) {
swap(*a->storage_.GetAllocPtr(), *b->storage_.GetAllocPtr());
}
assert(b->size() == a_size);

12
absl/container/internal/inlined_vector.h
View file

@ -33,7 +33,7 @@ using IsAtLeastForwardIterator = std::is_convertible<
std::forward_iterator_tag>;
template <typename AllocatorType, typename ValueType, typename SizeType>
void DestroyElements(AllocatorType alloc, ValueType* destroy_first,
void DestroyElements(AllocatorType* alloc_ptr, ValueType* destroy_first,
SizeType destroy_size) {
using AllocatorTraits = std::allocator_traits<AllocatorType>;
@ -45,7 +45,7 @@ void DestroyElements(AllocatorType alloc, ValueType* destroy_first,
// NOTE: We assume destructors do not throw and thus make no attempt to roll
// back.
for (SizeType i = 0; i < destroy_size; ++i) {
AllocatorTraits::destroy(alloc, destroy_first + i);
AllocatorTraits::destroy(*alloc_ptr, destroy_first + i);
}
#ifndef NDEBUG
@ -104,10 +104,12 @@ class Storage {
return data_.allocated.allocated_capacity;
}
allocator_type& GetAllocator() { return metadata_.template get<0>(); }
allocator_type* GetAllocPtr() {
return std::addressof(metadata_.template get<0>());
}
const allocator_type& GetAllocator() const {
return metadata_.template get<0>();
const allocator_type* GetAllocPtr() const {
return std::addressof(metadata_.template get<0>());
}
void SetAllocatedSize(size_type size) {

2
absl/flags/parse.cc
View file

@ -190,7 +190,7 @@ bool GetEnvVar(const char* var_name, std::string* var_value) {
char buf[1024];
auto get_res = GetEnvironmentVariableA(var_name, buf, sizeof(buf));
if (get_res >= sizeof(buf)) {
return "";
return false;
}
if (get_res == 0) {

4
absl/types/optional.h
View file

@ -421,7 +421,9 @@ class optional : private optional_internal::optional_data<T>,
//
// Accesses the underlying `T` value of an `optional`. If the `optional` is
// empty, behavior is undefined.
constexpr const T& operator*() const & { return reference(); }
constexpr const T& operator*() const& {
return ABSL_ASSERT(this->engaged_), reference();
}
T& operator*() & {
assert(this->engaged_);
return reference();