#include <esp/core/Spimpl.h>
template<class T, class Deleter = details::default_deleter_t<T>, class Copier = details::default_copier_t<T>>
spimpl::impl_ptr class

Public types

using pointer = T*
using const_pointer = typename std::add_const<T>::type*
using reference = T&
using const_reference = typename std::add_const<T>::type&
using element_type = T
using copier_type = typename std::decay<Copier>::type
using deleter_type = typename std::decay<Deleter>::type
using unique_ptr_type = std::unique_ptr<T, deleter_type>
using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>

Constructors, destructors, conversion operators

impl_ptr() constexpr noexcept
impl_ptr(std::nullptr_t) explicit constexpr noexcept
template<class D, class C>
impl_ptr(pointer p, D&& d, C&& c, typename std::enable_if<std::is_convertible<D, deleter_type>::value && std::is_convertible<C, copier_type>::value, dummy_t_>::type = dummy_t_()) noexcept
template<class U>
impl_ptr(U* u, typename std::enable_if<std::is_convertible<U*, pointer>::value && is_default_manageable::value, dummy_t_>::type = dummy_t_()) explicit noexcept
impl_ptr(const impl_ptr& r)
impl_ptr(impl_ptr&& r) defaulted noexcept
template<class U>
impl_ptr(std::unique_ptr<U>&& u, typename std::enable_if<std::is_convertible<U*, pointer>::value && is_default_manageable::value, dummy_t_>::type = dummy_t_()) explicit noexcept
template<class U, class D, class C>
impl_ptr(std::unique_ptr<U, D>&& u, C&& c, typename std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value && std::is_convertible<C, copier_type>::value, dummy_t_>::type = dummy_t_()) noexcept
template<class U, class D, class C>
impl_ptr(impl_ptr<U, D, C>&& u, typename std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value && std::is_convertible<C, copier_type>::value, dummy_t_>::type = dummy_t_()) explicit noexcept
operator bool() const explicit noexcept

Public functions

auto operator=(const impl_ptr& r) -> impl_ptr&
auto operator=(impl_ptr&& r) -> impl_ptr& defaulted noexcept
template<class U, class D, class C>
auto operator=(impl_ptr<U, D, C>&& u) -> std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value && std::is_convertible<C, copier_type>::value, impl_ptr&>::type noexcept
template<class U, class D, class C>
auto operator=(const impl_ptr<U, D, C>& u) -> std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value && std::is_convertible<C, copier_type>::value, impl_ptr&>::type
template<class U>
auto operator=(std::unique_ptr<U>&& u) -> std::enable_if<std::is_convertible<U*, pointer>::value && is_default_manageable::value, impl_ptr&>::type noexcept
auto clone() const -> impl_ptr
auto operator*() -> reference
auto operator*() const -> const_reference
auto operator->() -> pointer noexcept
auto operator->() const -> const_pointer noexcept
auto get() -> pointer noexcept
auto get() const -> const_pointer noexcept
void swap(impl_ptr& u) noexcept
auto release() -> pointer noexcept
auto release_unique() -> unique_ptr_type noexcept
auto get_deleter() -> std::remove_reference<deleter_type>::type& noexcept
auto get_deleter() const -> const std::remove_reference<deleter_type>::type& noexcept
auto get_copier() -> std::remove_reference<copier_type>::type& noexcept
auto get_copier() const -> const std::remove_reference<copier_type>::type& noexcept