maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
4a7dc9bd72a50f493671ea3ae2a571462cb70fc4 by Jon Cohen <cohenjon@google.com>:

Use -ignore instead of /ignore.  CMake was interpreting /ignore as a path and changing it it \ignore in windows builds, expecting it to be some sort of file.

Close #293

PiperOrigin-RevId: 242134552

--
8de3e403667f677859584bb321ef8fce3253af18 by CJ Johnson <johnsoncj@google.com>:

In InlinedVector: Migrates `Rep` to `Data` getting rid of the `Allocation` class.

PiperOrigin-RevId: 242130255
GitOrigin-RevId: 4a7dc9bd72a50f493671ea3ae2a571462cb70fc4
Change-Id: Ic7ff4c572bba7a411155bf304b9cae10d68599db
This commit is contained in:
Abseil Team 2019-04-05 09:05:22 -07:00 • committed by Jon Cohen
parent 666fc1266b
commit 6cc6ac44e0
5 changed files with 95 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -33,8 +33,6 @@ template <template <typename, size_t, typename> class InlinedVector, typename T,
size_t N, typename A>
class Storage<InlinedVector<T, N, A>> {
public:
class Allocation; // TODO(johnsoncj): Remove after migration
using allocator_type = A;
using value_type = typename allocator_type::value_type;
using pointer = typename allocator_type::pointer;
@ -48,6 +46,7 @@ class Storage<InlinedVector<T, N, A>> {
using const_iterator = const_pointer;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using AllocatorTraits = std::allocator_traits<allocator_type>;
explicit Storage(const allocator_type& alloc)
: metadata_(alloc, /* empty and inlined */ 0) {}
@ -56,30 +55,25 @@ class Storage<InlinedVector<T, N, A>> {
bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
Allocation& GetAllocation() {
return reinterpret_cast<Allocation&>(rep_.allocation_storage.allocation);
}
const Allocation& GetAllocation() const {
return reinterpret_cast<const Allocation&>(
rep_.allocation_storage.allocation);
}
pointer GetInlinedData() {
return reinterpret_cast<pointer>(
std::addressof(rep_.inlined_storage.inlined[0]));
std::addressof(data_.inlined.inlined_data[0]));
}
const_pointer GetInlinedData() const {
return reinterpret_cast<const_pointer>(
std::addressof(rep_.inlined_storage.inlined[0]));
std::addressof(data_.inlined.inlined_data[0]));
}
pointer GetAllocatedData() { return GetAllocation().buffer(); }
pointer GetAllocatedData() { return data_.allocated.allocated_data; }
const_pointer GetAllocatedData() const { return GetAllocation().buffer(); }
const_pointer GetAllocatedData() const {
return data_.allocated.allocated_data;
}
size_type GetAllocatedCapacity() const { return GetAllocation().capacity(); }
size_type GetAllocatedCapacity() const {
return data_.allocated.allocated_capacity;
}
allocator_type& GetAllocator() { return metadata_.template get<0>(); }
@ -95,34 +89,23 @@ class Storage<InlinedVector<T, N, A>> {
void AddSize(size_type count) { GetSizeAndIsAllocated() += count << 1; }
void InitAllocation(const Allocation& allocation) {
new (static_cast<void*>(std::addressof(rep_.allocation_storage.allocation)))
Allocation(allocation);
void SetAllocatedData(pointer data) {
data_.allocated.allocated_data = data;
}
void SwapSizeAndIsAllocated(Storage& other) {
void SetAllocatedCapacity(size_type capacity) {
data_.allocated.allocated_capacity = capacity;
}
void SwapSizeAndIsAllocated(Storage* other) {
using std::swap;
swap(GetSizeAndIsAllocated(), other.GetSizeAndIsAllocated());
swap(GetSizeAndIsAllocated(), other->GetSizeAndIsAllocated());
}
// TODO(johnsoncj): Make the below types private after migration
class Allocation {
size_type capacity_;
pointer buffer_;
public:
Allocation(allocator_type& a, size_type capacity)
: capacity_(capacity), buffer_(Create(a, capacity)) {}
void Dealloc(allocator_type& a) {
std::allocator_traits<allocator_type>::deallocate(a, buffer_, capacity_);
}
size_type capacity() const { return capacity_; }
const_pointer buffer() const { return buffer_; }
pointer buffer() { return buffer_; }
static pointer Create(allocator_type& a, size_type n) {
return std::allocator_traits<allocator_type>::allocate(a, n);
}
};
void SwapAllocatedSizeAndCapacity(Storage* other) {
using std::swap;
swap(data_.allocated, other->data_.allocated);
}
private:
size_type& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
@ -131,29 +114,27 @@ class Storage<InlinedVector<T, N, A>> {
return metadata_.template get<1>();
}
// Stores either the inlined or allocated representation
union Rep {
using ValueTypeBuffer =
absl::aligned_storage_t<sizeof(value_type), alignof(value_type)>;
using AllocationBuffer =
absl::aligned_storage_t<sizeof(Allocation), alignof(Allocation)>;
using Metadata =
container_internal::CompressedTuple<allocator_type, size_type>;
// Structs wrap the buffers to perform indirection that solves a bizarre
// compilation error on Visual Studio (all known versions).
struct InlinedRep {
ValueTypeBuffer inlined[N];
};
struct AllocatedRep {
AllocationBuffer allocation;
};
InlinedRep inlined_storage;
AllocatedRep allocation_storage;
struct Allocated {
pointer allocated_data;
size_type allocated_capacity;
};
container_internal::CompressedTuple<allocator_type, size_type> metadata_;
Rep rep_;
struct Inlined {
using InlinedDataElement =
absl::aligned_storage_t<sizeof(value_type), alignof(value_type)>;
InlinedDataElement inlined_data[N];
};
union Data {
Allocated allocated;
Inlined inlined;
};
Metadata metadata_;
Data data_;
};
} // namespace inlined_vector_internal