Template Class unique_impl_ptr

Defined in File impl_ptr.hpp

Nested Relationships

Nested Types

Struct unique_impl_ptr::dummy_t_

Inheritance Relationships

Derived Types

public rmf_utils::impl_ptr< Implementation > (Template Class impl_ptr)
public rmf_utils::impl_ptr< T, Deleter, Copier > (Template Class impl_ptr)

Class Documentation

template<class T, class Deleter = details::default_deleter_t<T>> class unique_impl_ptr

Subclassed by rmf_utils::impl_ptr< Implementation >, rmf_utils::impl_ptr< T, Deleter, Copier >

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 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>

Public Functions

inline constexpr unique_impl_ptr() noexcept

inline constexpr unique_impl_ptr(std::nullptr_t) noexcept

template<class D> inline unique_impl_ptr(pointer p, D &&d, typename std::enable_if<std::is_convertible<D, deleter_type>::value, dummy_t_>::type = dummy_t_()) noexcept

template<class U> inline unique_impl_ptr(U *u, typename std::enable_if<std::is_convertible<U*, pointer>::value && is_default_manageable::value, dummy_t_>::type = dummy_t_()) noexcept

unique_impl_ptr(unique_impl_ptr &&r) noexcept = default

template<class U> inline unique_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_()) noexcept

template<class U, class D> inline unique_impl_ptr(std::unique_ptr<U, D> &&u, typename std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value, dummy_t_>::type = dummy_t_()) noexcept

template<class U, class D> inline unique_impl_ptr(unique_impl_ptr<U, D> &&u, typename std::enable_if<std::is_convertible<U*, pointer>::value && std::is_convertible<D, deleter_type>::value, dummy_t_>::type = dummy_t_()) noexcept

unique_impl_ptr(const unique_impl_ptr<T, Deleter>&) = delete

unique_impl_ptr &operator=(unique_impl_ptr &&r) noexcept = default

template<class U> inline std::enable_if<std::is_convertible<U*, pointer>::value && is_default_manageable::value, unique_impl_ptr&>::type operator=(std::unique_ptr<U> &&u) noexcept

reference operator=(const unique_impl_ptr<T, Deleter>&) = delete

inline reference operator*()

inline const_reference operator*() const

inline pointer operator->() noexcept

inline const_pointer operator->() const noexcept

inline pointer get() noexcept

inline const_pointer get() const noexcept

inline void swap(unique_impl_ptr &u) noexcept

inline pointer release() noexcept

inline unique_ptr_type release_unique() noexcept

inline explicit operator bool() const noexcept

inline std::remove_reference<deleter_type>::type &get_deleter() noexcept

inline const std::remove_reference<deleter_type>::type &get_deleter() const noexcept

Protected Attributes

unique_ptr_type ptr_

struct dummy_t_

Public Members

int dummy__