c++-gtk-utils
Namespaces | Classes | Typedefs | Enumerations | Functions
handles and smart pointers

Namespaces

 Cgu::SharedHandleAllocFail
 
 Cgu::SharedPtrAllocFail
 

Classes

class  Cgu::GerrorFree
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls glib's g_error_free(). More...
 
class  Cgu::GobjHandle< T >
 This is a handle for managing the reference count of GObjects. More...
 
class  Cgu::GobjWeakHandle< T >
 This is a handle for managing weak references to GObjects. More...
 
class  Cgu::GvarHandle
 This is a handle for managing the reference count of GVariant objects. More...
 
class  Cgu::IntrusivePtr< T >
 This is a smart pointer for managing objects allocated on freestore which maintain their own reference count. More...
 
class  Cgu::IntrusiveCounter
 This is a counter class providing the ref() and unref() functions required by IntrusivePtr. More...
 
class  Cgu::IntrusiveLockCounter
 This is a counter class providing the ref() and unref() functions required by IntrusivePtr, with a thread safe reference count.. More...
 
class  Cgu::SharedHandle< T, Dealloc >
 This is a generic class for managing the lifetime of objects allocated on freestore. More...
 
class  Cgu::StandardArrayDelete< T >
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls the C++ delete[] expression. More...
 
class  Cgu::CFree
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls std::free. More...
 
class  Cgu::GFree
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls glib's g_free(). More...
 
class  Cgu::GSliceFree< T >
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls glib's g_slice_free1(). More...
 
class  Cgu::GSliceDestroy< T >
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls glib's g_slice_free1(), but before doing so also explicitly calls the destructor of a C++ object constructed in the memory. More...
 
class  Cgu::GSliceFreeSize< block_size >
 A deleter functor for use as the second (Dealloc) template parameter of the SharedHandle, SharedLockHandle or ScopedHandle template classes, which calls glib's g_slice_free1(). More...
 
class  Cgu::SharedHandleError< T >
 This is an exception struct thrown as an alternative to deleting a managed object when internal memory allocation for SharedHandle or SharedLockHandle fails in their reset() method or in their constructor which takes a pointer. More...
 
class  Cgu::ScopedHandle< T, Dealloc >
 This is a generic scoped class for managing the lifetime of objects allocated on freestore. More...
 
class  Cgu::SharedLockHandle< T, Dealloc >
 This is a generic class for managing the lifetime of objects allocated on freestore, with a thread safe reference count.. More...
 
class  Cgu::SharedPtrError< T >
 This is an exception struct thrown as an alternative to deleting a managed object when internal memory allocation for SharedPtr or SharedLockPtr fails in their reset() method or in their constructor which takes a pointer. More...
 
class  Cgu::SharedPtr< T >
 This is a smart pointer for managing the lifetime of objects allocated on freestore. More...
 
class  Cgu::SharedLockPtr< T >
 This is a smart pointer for managing the lifetime of objects allocated on freestore, with a thread safe reference count. More...
 

Typedefs

typedef ScopedHandle< GError *, GerrorFree > Cgu::GerrorScopedHandle
 A handle comprising a typed instance of the ScopedHandle class for managing GError objects. More...
 
typedef SharedHandle< GError *, GerrorFree > Cgu::GerrorSharedHandle
 A handle comprising a typed instance of the SharedHandle class for managing GError objects. More...
 
typedef SharedHandle< gchar *, GFree > Cgu::GcharSharedHandle
 A handle comprising a typed instance of the SharedHandle class for gchar* arrays and strings. More...
 
typedef ScopedHandle< gchar *, GFree > Cgu::GcharScopedHandle
 A handle comprising a typed instance of the ScopedHandle class for gchar* arrays and strings. More...
 

Enumerations

enum  Cgu::SharedHandleAllocFail::Leave { Cgu::SharedHandleAllocFail::leave }
 
enum  Cgu::SharedPtrAllocFail::Leave { Cgu::SharedPtrAllocFail::leave }
 

Functions

template<class T >
bool Cgu::operator== (const GobjHandle< T > &h1, const GobjHandle< T > &h2)
 
template<class T >
bool Cgu::operator!= (const GobjHandle< T > &h1, const GobjHandle< T > &h2)
 
template<class T >
bool Cgu::operator< (const GobjHandle< T > &h1, const GobjHandle< T > &h2)
 
bool Cgu::operator== (const GvarHandle &h1, const GvarHandle &h2)
 
bool Cgu::operator!= (const GvarHandle &h1, const GvarHandle &h2)
 
bool Cgu::operator< (const GvarHandle &h1, const GvarHandle &h2)
 
template<class T >
bool Cgu::operator== (const IntrusivePtr< T > &s1, const IntrusivePtr< T > &s2)
 
template<class T >
bool Cgu::operator!= (const IntrusivePtr< T > &s1, const IntrusivePtr< T > &s2)
 
template<class T >
bool Cgu::operator< (const IntrusivePtr< T > &s1, const IntrusivePtr< T > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator== (const SharedHandle< T, Dealloc > &s1, const SharedHandle< T, Dealloc > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator!= (const SharedHandle< T, Dealloc > &s1, const SharedHandle< T, Dealloc > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator< (const SharedHandle< T, Dealloc > &s1, const SharedHandle< T, Dealloc > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator== (const SharedLockHandle< T, Dealloc > &s1, const SharedLockHandle< T, Dealloc > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator!= (const SharedLockHandle< T, Dealloc > &s1, const SharedLockHandle< T, Dealloc > &s2)
 
template<class T , class Dealloc >
bool Cgu::operator< (const SharedLockHandle< T, Dealloc > &s1, const SharedLockHandle< T, Dealloc > &s2)
 
template<class T >
bool Cgu::operator== (const SharedPtr< T > &s1, const SharedPtr< T > &s2)
 
template<class T >
bool Cgu::operator!= (const SharedPtr< T > &s1, const SharedPtr< T > &s2)
 
template<class T >
bool Cgu::operator< (const SharedPtr< T > &s1, const SharedPtr< T > &s2)
 
template<class T >
bool Cgu::operator== (const SharedLockPtr< T > &s1, const SharedLockPtr< T > &s2)
 
template<class T >
bool Cgu::operator!= (const SharedLockPtr< T > &s1, const SharedLockPtr< T > &s2)
 
template<class T >
bool Cgu::operator< (const SharedLockPtr< T > &s1, const SharedLockPtr< T > &s2)
 

Detailed Description

Typedef Documentation

A handle comprising a typed instance of the ScopedHandle class for gchar* arrays and strings.

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

A handle comprising a typed instance of the SharedHandle class for gchar* arrays and strings.

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

A handle comprising a typed instance of the ScopedHandle class for managing GError objects.

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

A handle comprising a typed instance of the SharedHandle class for managing GError objects.

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

Enumeration Type Documentation

Enumerator
leave 
Enumerator
leave 

Function Documentation

bool Cgu::operator!= ( const GvarHandle h1,
const GvarHandle h2 
)
inline

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gvar_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator!= ( const IntrusivePtr< T > &  s1,
const IntrusivePtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before intrusive_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator!= ( const GobjHandle< T > &  h1,
const GobjHandle< T > &  h2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gobj_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator!= ( const SharedPtr< T > &  s1,
const SharedPtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator!= ( const SharedLockPtr< T > &  s1,
const SharedLockPtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator!= ( const SharedHandle< T, Dealloc > &  s1,
const SharedHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator!= ( const SharedLockHandle< T, Dealloc > &  s1,
const SharedLockHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12

bool Cgu::operator< ( const GvarHandle h1,
const GvarHandle h2 
)
inline

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gvar_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator< ( const IntrusivePtr< T > &  s1,
const IntrusivePtr< T > &  s2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before intrusive_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator< ( const GobjHandle< T > &  h1,
const GobjHandle< T > &  h2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gobj_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator< ( const SharedPtr< T > &  s1,
const SharedPtr< T > &  s2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator< ( const SharedLockPtr< T > &  s1,
const SharedLockPtr< T > &  s2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator< ( const SharedHandle< T, Dealloc > &  s1,
const SharedHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator< ( const SharedLockHandle< T, Dealloc > &  s1,
const SharedLockHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw unless std::less applied to pointer types throws (which it would not do with any sane implementation). It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12

bool Cgu::operator== ( const GvarHandle h1,
const GvarHandle h2 
)
inline

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gvar_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator== ( const IntrusivePtr< T > &  s1,
const IntrusivePtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before intrusive_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator== ( const GobjHandle< T > &  h1,
const GobjHandle< T > &  h2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before gobj_handle.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator== ( const SharedPtr< T > &  s1,
const SharedPtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T >
bool Cgu::operator== ( const SharedLockPtr< T > &  s1,
const SharedLockPtr< T > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_ptr.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator== ( const SharedHandle< T, Dealloc > &  s1,
const SharedHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12

template<class T , class Dealloc >
bool Cgu::operator== ( const SharedLockHandle< T, Dealloc > &  s1,
const SharedLockHandle< T, Dealloc > &  s2 
)

This comparison operator does not throw. It compares the addresses of the managed objects. This function is only available if the library is compiled with the --with-smart-ptr-comp option, or if the user code defines the symbol CGU_USE_SMART_PTR_COMPARISON before shared_handle.h is first parsed.

Since 1.2.12