Classes | Namespaces | Functions
container_memory.h File Reference
#include <cassert>
#include <cstddef>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/utility/utility.h"
Include dependency graph for container_memory.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  absl::container_internal::memory_internal::IsLayoutCompatible< K, V >
 
struct  absl::container_internal::map_slot_policy< K, V >
 
union  absl::container_internal::map_slot_type< K, V >
 
struct  absl::container_internal::memory_internal::OffsetOf< Pair, class >
 
struct  absl::container_internal::memory_internal::OffsetOf< Pair, typename std::is_standard_layout< Pair >::type >
 
struct  absl::container_internal::memory_internal::IsLayoutCompatible< K, V >::Pair
 
struct  absl::container_internal::memory_internal::WithConstructedImplF< T, F >
 

Namespaces

 absl
 
 absl::container_internal
 
 absl::container_internal::memory_internal
 

Functions

template<size_t Alignment, class Alloc >
void * absl::container_internal::Allocate (Alloc *alloc, size_t n)
 
template<class Alloc , class T , class Tuple >
void absl::container_internal::ConstructFromTuple (Alloc *alloc, T *ptr, Tuple &&t)
 
template<class Alloc , class T , class Tuple , size_t... I>
void absl::container_internal::memory_internal::ConstructFromTupleImpl (Alloc *alloc, T *ptr, Tuple &&t, absl::index_sequence< I... >)
 
template<size_t Alignment, class Alloc >
void absl::container_internal::Deallocate (Alloc *alloc, void *p, size_t n)
 
template<class F , class... Args>
auto absl::container_internal::DecomposePair (F &&f, Args &&... args) -> decltype(memory_internal::DecomposePairImpl(std::forward< F >(f), PairArgs(std::forward< Args >(args)...)))
 
template<class F , class K , class V >
decltype(std::declval< F >()(std::declval< const K & >(), std::piecewise_construct, std::declval< std::tuple< K >>(), std::declval< V >())) absl::container_internal::memory_internal::DecomposePairImpl (F &&f, std::pair< std::tuple< K >, V > p)
 
template<class F , class Arg >
decltype(std::declval< F >()(std::declval< const Arg & >(), std::declval< Arg >())) absl::container_internal::DecomposeValue (F &&f, Arg &&arg)
 
std::pair< std::tuple<>, std::tuple<> > absl::container_internal::PairArgs ()
 
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > > absl::container_internal::PairArgs (F &&f, S &&s)
 
template<class F , class S >
std::pair< std::tuple< const F & >, std::tuple< const S & > > absl::container_internal::PairArgs (const std::pair< F, S > &p)
 
template<class F , class S >
std::pair< std::tuple< F && >, std::tuple< S && > > absl::container_internal::PairArgs (std::pair< F, S > &&p)
 
template<class F , class S >
auto absl::container_internal::PairArgs (std::piecewise_construct_t, F &&f, S &&s) -> decltype(std::make_pair(memory_internal::TupleRef(std::forward< F >(f)), memory_internal::TupleRef(std::forward< S >(s))))
 
void absl::container_internal::SanitizerPoisonMemoryRegion (const void *m, size_t s)
 
template<typename T >
void absl::container_internal::SanitizerPoisonObject (const T *object)
 
void absl::container_internal::SanitizerUnpoisonMemoryRegion (const void *m, size_t s)
 
template<typename T >
void absl::container_internal::SanitizerUnpoisonObject (const T *object)
 
template<class T >
auto absl::container_internal::memory_internal::TupleRef (T &&t) -> decltype(TupleRefImpl(std::forward< T >(t), absl::make_index_sequence< std::tuple_size< typename std::decay< T >::type >::value >()))
 
template<class T , size_t... Is>
auto absl::container_internal::memory_internal::TupleRefImpl (T &&t, absl::index_sequence< Is... >) -> decltype(std::forward_as_tuple(std::get< Is >(std::forward< T >(t))...))
 
template<class T , class Tuple , class F >
decltype(std::declval< F >()(std::declval< T >())) absl::container_internal::WithConstructed (Tuple &&t, F &&f)
 
template<class T , class Tuple , size_t... Is, class F >
decltype(std::declval< F >()(std::declval< T >())) absl::container_internal::memory_internal::WithConstructedImpl (Tuple &&t, absl::index_sequence< Is... >, F &&f)
 


abseil_cpp
Author(s):
autogenerated on Mon Feb 28 2022 21:31:22