esp/core/spimpl.h file

Namespaces

namespace spimpl
namespace spimpl::details
namespace std
STL namespace.

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
template<class T, class D, class C>
struct std::hash<spimpl::impl_ptr<T, D, C>>

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