Spimpl.h file

Namespaces

namespace spimpl
namespace spimpl::details

Classes

template<class T> struct spimpl::details::default_deleter
template<class T> struct spimpl::details::default_copier
template<class T, class D, class C> struct spimpl::details::is_default_manageable
template<class T, class Deleter = details::default_deleter_t<T>, class Copier = details::default_copier_t<T>> class spimpl::impl_ptr

Typedefs

template<class T> using default_deleter_t = typename default_deleter<T>::type
template<class T> using default_copier_t = typename default_copier<T>::type
template<class T, class Deleter = void (*)(T*)> using unique_impl_ptr = std::unique_ptr<T, Deleter>

Functions

template<class T> auto default_copy(T* src) -> T*
template<class T> void default_delete(T* p) noexcept
template<class T, class D, class C> void swap(impl_ptr<T, D, C>& l, impl_ptr<T, D, C>& r) noexcept
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator==(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator!=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator<(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator>(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator<=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T1, class D1, class C1, class T2, class D2, class C2> auto operator>=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r) -> bool
template<class T, class D, class C> auto operator==(const impl_ptr<T, D, C>& p, std::nullptr_t) -> bool noexcept
template<class T, class D, class C> auto operator==(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool noexcept
template<class T, class D, class C> auto operator!=(const impl_ptr<T, D, C>& p, std::nullptr_t) -> bool noexcept
template<class T, class D, class C> auto operator!=(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool noexcept
template<class T, class D, class C> auto operator<(const impl_ptr<T, D, C>& l, std::nullptr_t) -> bool
template<class T, class D, class C> auto operator<(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool
template<class T, class D, class C> auto operator>(const impl_ptr<T, D, C>& p, std::nullptr_t) -> bool
template<class T, class D, class C> auto operator>(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool
template<class T, class D, class C> auto operator<=(const impl_ptr<T, D, C>& p, std::nullptr_t) -> bool
template<class T, class D, class C> auto operator<=(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool
template<class T, class D, class C> auto operator>=(const impl_ptr<T, D, C>& p, std::nullptr_t) -> bool
template<class T, class D, class C> auto operator>=(std::nullptr_t, const impl_ptr<T, D, C>& p) -> bool
template<class T, class... Args> auto make_impl(Args && ... args) -> impl_ptr<T>
template<class T, class... Args> auto make_unique_impl(Args && ... args) -> unique_impl_ptr<T>

Defines

#define SPIMPL_NOEXCEPT
#define SPIMPL_CONSTEXPR