std::experimental::unique_resource(3)

NAME
std::experimental::unique_resource - std::experimental::unique_resource

Synopsis
   Defined in header <experimental/scope>
   template<class R, class D> (library fundamentals TS v3)
   class unique_resource;
   unique_resource is universal RAII wrapper for resource handles that owns and manages
   a resource through a handle and disposes of that resource when the unique_resource
   is destroyed.
   The resource is disposed of using the deleter of type D when either of the following
   happens:
     * the managing unique_resource object is destroyed
     * the managing unique_resource object is assigned from another resource via
       operator= or reset().
   Let type RS be R if R is an object type, or
   std::reference_wrapper<std::remove_reference_t<R>> otherwise:
     * unique_resource effectively holds a subobject of type RS which is or wraps the
       resource handle, a deleter of type D and a bool flag indicating whether the
       wrapper is owning the resource.
     * For explanatory purpose, the subobject of type RS is called stored resource
       handle, and the stored (if R is an object type) or wrapped (if R is a reference
       type) R is called underlying resource handle. These two terms are not used by
       the LFTS.

Template parameters
   R - resource handle type
   D - deleter type

Type requirements
   -
   R shall be an object type or an lvalue reference to an object type. Let UnrefR be
   std::remove_reference_t<R>, UnrefR shall be MoveConstructible, and if UnrefR is not
   CopyConstructible, std::is_nothrow_move_constructible_v<UnrefR> shall be true.
   -
   D shall be a Destructible and MoveConstructible FunctionObject type, and if D is not
   CopyConstructible, std::is_nothrow_move_constructible_v<D> shall be true. Given an
   lvalue d of type D and an lvalue r of type UnrefR, the expression d(r) shall be
   well-formed.

Member functions
   constructor constructs a new unique_resource
                 (public member function)
   destructor disposes the managed resource if such is present
                 (public member function)
   operator= assigns a unique_resource
                 (public member function)

Modifiers
   release releases the ownership
                 (public member function)
   reset disposes or replaces the managed resource
                 (public member function)

Observers
   get accesses the underlying resource handle
                 (public member function)
   get_deleter accesses the deleter used for disposing of the managed resource
                 (public member function)
   operator* accesses the pointee if the resource handle is a pointer
   operator-> (public member function)

Non-member functions
   make_unique_resource_checked creates a unique_resource, checking invalid value
                        (function template)
  Deduction guides

Notes
   Resource handle types satisfying NullablePointer can also be managed by
   std::unique_ptr. Unlike unique_ptr, unique_resource does not require
   NullablePointer.

Example
    This section is incomplete
    Reason: no example

See also
   unique_ptr smart pointer with unique object ownership semantics
   (C++11) (class template)