Cgu::ScopedHandle< T, Dealloc > Class Template Reference
handles and smart pointers

This is a generic scoped class for managing the lifetime of objects allocated on freestore. More...

`#include <c++-gtk-utils/shared_handle.h>`

## Public Member Functions

| ScopedHandle (const ScopedHandle &)=delete
ScopedHandle & | operator= (const ScopedHandle &)=delete
| ScopedHandle (ScopedHandle &&sc_hand) noexcept
ScopedHandle & | operator= (ScopedHandle &&sc_hand)
| ScopedHandle (T ptr=0) noexcept
void | reset (T ptr=0)
T | release () noexcept
T | get () const noexcept
| operator T () const noexcept
| ~ScopedHandle ()

## Detailed Description

### template<class T, class Dealloc>
class Cgu::ScopedHandle< T, Dealloc >

This is a generic scoped class for managing the lifetime of objects allocated on freestore.

See Also
  SharedHandle SharedLockHandle SharedHandleError
  StandardArrayDelete CFree GFree GerrorFree GSliceFree GSliceFreeSize GSliceDestroy

This class deletes its object as soon as it goes out of scope. It can be viewed as a SharedHandle which cannot be copy assigned to or used as the argument to a copy constructor and therefore which cannot have a reference count of more than 1.

ScopedHandle objects can be instantiated for pointers to constant objects (such as ScopedHandle<const char*>), provided the deleter functor will take such pointers.

This library provides StandardArrayDelete, CFree, GFree, GerrorFree, GSliceFree, GSliceFreeSize and GSliceDestroy deleter functors, which can be used as the second template parameter of the ScopedHandle class. StandardArrayDelete is the default, and some typedef'ed instances of ScopedHandle for gchar (with the GFree deleter) and for GError (with the GerrorFree deleter) are provided: GcharScopedHandle and GerrorScopedHandle)

Comparison with std::unique_ptr

This class is mainly retained to retain compatibility with series 1.2 of the library, since most of the things that can be done with it can also be done using std::unique_ptr. However, this class is a little easier to use when managing objects with associated C functions (such as in glib), because it provides a type conversion operator.

From version 2.2.2, this class has a move constructor and move assignment operator. Prior to that, it could not be moved from or to.

## Constructor & Destructor Documentation

template<class T, class Dealloc>

Cgu::ScopedHandle< T, Dealloc >::ScopedHandle | ( | const ScopedHandle< T, Dealloc > & | ) |  |

delete

This class cannot be copied. The copy constructor is deleted.

template<class T, class Dealloc>

Cgu::ScopedHandle< T, Dealloc >::ScopedHandle | ( | ScopedHandle< T, Dealloc > && | sc_hand) |  |

inline noexcept

The move constructor does not throw.

Parameters

  sc_hand | The handle to be moved.

Since 2.0.19/2.2.2

template<class T, class Dealloc>

Cgu::ScopedHandle< T, Dealloc >::ScopedHandle | ( | T | ptr = `0`) |  |

inline explicit noexcept

This constructor does not throw.

Parameters

  ptr | The object which the ScopedHandle is to manage (if any).

ScopedHandle objects can be instantiated for pointers to constant objects (such as SharedHandle<const char*>), provided the deleter functor will take such pointers.

template<class T, class Dealloc>

Cgu::ScopedHandle< T, Dealloc >::~ScopedHandle | ( | ) |  |

inline

The destructor does not throw unless the destructor of a handled object throws - that should never happen.

## Member Function Documentation

template<class T, class Dealloc>

T Cgu::ScopedHandle< T, Dealloc >::get | ( | ) |  | const

inline noexcept

This method does not throw.

Returns
  A pointer to the handled object (or NULL if none is handled).

template<class T, class Dealloc>

Cgu::ScopedHandle< T, Dealloc >::operator T | ( | ) |  | const

inline noexcept

This method does not throw.

Returns
  A pointer to the handled object (or NULL if none is handled).

template<class T, class Dealloc>

ScopedHandle& Cgu::ScopedHandle< T, Dealloc >::operator= | ( | const ScopedHandle< T, Dealloc > & | ) |  |

delete

This class cannot be copied. The copy assignment operator is deleted.

template<class T, class Dealloc>

ScopedHandle& Cgu::ScopedHandle< T, Dealloc >::operator= | ( | ScopedHandle< T, Dealloc > && | sc_hand) |  |

inline

The move assignment operator. It will delete the object managed prior to the move, if any. It does not throw unless the destructor of that object throws.

Parameters

  sc_hand | The handle to be moved.

Returns
  The ScopedHandle object after move assignment.

Since 2.0.19/2.2.2

template<class T, class Dealloc>

T Cgu::ScopedHandle< T, Dealloc >::release | ( | ) |  |

inline noexcept

Causes the ScopedHandle to cease to manage the handled object, but does not delete that object. This method does not throw.

Returns
  A pointer to the previously handled object (or NULL if none was handled).

template<class T, class Dealloc>

void Cgu::ScopedHandle< T, Dealloc >::reset | ( | T | ptr = `0`) |  |

inline

Causes the ScopedHandle to delete its managed object (if any), and if the argument passed is not NULL, the ScopedHandle object will manage the new object passed (which must not be managed by any other ScopedHandle object). This method does not throw (assuming the destructor of a managed object does not throw).

Parameters

  ptr | NULL (the default), or a new unmanaged object to manage.

The documentation for this class was generated from the following file:

- shared_handle.h