memory.h File Reference

#include <cstddef>
#include <limits>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"

Include dependency graph for memory.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	absl::allocator_is_nothrow< Alloc >
struct	absl::allocator_traits< Alloc >
struct	absl::default_allocator_is_nothrow
struct	absl::memory_internal::ElementType< Ptr, typename >
struct	absl::memory_internal::ElementType< T, void_t< typename T::element_type > >
struct	absl::memory_internal::ExtractOr< Extract, Obj, Default, typename >
struct	absl::memory_internal::ExtractOr< Extract, Obj, Default, void_t< Extract< Obj > > >
struct	absl::memory_internal::GetFirstArg< T >
struct	absl::memory_internal::GetFirstArg< Class< T, Args... > >
struct	absl::memory_internal::MakeUniqueResult< T >
struct	absl::memory_internal::MakeUniqueResult< T[]>
struct	absl::memory_internal::MakeUniqueResult< T[N]>
struct	absl::pointer_traits< Ptr >
struct	absl::pointer_traits< T * >
struct	absl::memory_internal::RebindAlloc< T, U, bool >
struct	absl::memory_internal::RebindAlloc< T, U, true >
struct	absl::memory_internal::RebindFirstArg< T, U >
struct	absl::memory_internal::RebindFirstArg< Class< T, Args... >, U >
struct	absl::memory_internal::RebindPtr< T, U, typename >
struct	absl::memory_internal::RebindPtr< T, U, void_t< typename T::template rebind< U > > >

Namespaces
	absl
	absl::memory_internal

Typedefs
template<template< typename > class Extract, typename Obj , typename Default >
using	absl::memory_internal::ExtractOrT = typename ExtractOr< Extract, Obj, Default, void >::type
template<typename T >
using	absl::memory_internal::GetConstPointer = typename T::const_pointer
template<typename T >
using	absl::memory_internal::GetConstVoidPointer = typename T::const_void_pointer
template<typename T >
using	absl::memory_internal::GetDifferenceType = typename T::difference_type
template<typename T >
using	absl::memory_internal::GetIsAlwaysEqual = typename T::is_always_equal
template<typename Alloc >
using	absl::memory_internal::GetIsNothrow = typename Alloc::is_nothrow
template<typename T >
using	absl::memory_internal::GetPointer = typename T::pointer
template<typename T >
using	absl::memory_internal::GetPropagateOnContainerCopyAssignment = typename T::propagate_on_container_copy_assignment
template<typename T >
using	absl::memory_internal::GetPropagateOnContainerMoveAssignment = typename T::propagate_on_container_move_assignment
template<typename T >
using	absl::memory_internal::GetPropagateOnContainerSwap = typename T::propagate_on_container_swap
template<typename T >
using	absl::memory_internal::GetSizeType = typename T::size_type
template<typename T >
using	absl::memory_internal::GetVoidPointer = typename T::void_pointer

Functions
template<typename Allocator , typename Iterator , typename... Args>
void	absl::memory_internal::ConstructRange (Allocator &alloc, Iterator first, Iterator last, const Args &... args)
template<typename Allocator , typename Iterator , typename InputIterator >
void	absl::memory_internal::CopyRange (Allocator &alloc, Iterator destination, InputIterator first, InputIterator last)
template<typename T , typename U >
constexpr bool	absl::memory_internal::HasRebindAlloc (...)
template<typename T , typename U >
constexpr bool	absl::memory_internal::HasRebindAlloc (typename T::template rebind< U >::other *)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::scalar	absl::make_unique (Args &&... args)
template<typename T >
memory_internal::MakeUniqueResult< T >::array	absl::make_unique (size_t n)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult< T >::invalid	absl::make_unique (Args &&...)=delete
template<typename T >
auto	absl::RawPtr (T &&ptr) -> decltype(std::addressof(*ptr))
std::nullptr_t	absl::RawPtr (std::nullptr_t)
template<typename T , typename D >
std::shared_ptr< T >	absl::ShareUniquePtr (std::unique_ptr< T, D > &&ptr)
template<typename T >
std::weak_ptr< T >	absl::WeakenPtr (const std::shared_ptr< T > &ptr)
template<typename T >
std::unique_ptr< T >	absl::WrapUnique (T *ptr)