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)