osg::observer_ptr< T > Class Template Reference

`#include <observer_ptr>`

## Public Types

typedef T | element_type

## Public Member Functions

| observer_ptr ()
| observer_ptr (const ref_ptr< T > &rp)
| observer_ptr (T *rp)
| observer_ptr (const observer_ptr &wp)
| ~observer_ptr ()
observer_ptr & | operator= (const observer_ptr &wp)
observer_ptr & | operator= (const ref_ptr< T > &rp)
observer_ptr & | operator= (T *rp)
bool | lock (ref_ptr< T > &rptr) const
bool | operator== (const observer_ptr &wp) const
bool | operator!= (const observer_ptr &wp) const
bool | operator< (const observer_ptr &wp) const
bool | operator> (const observer_ptr &wp) const
bool | operator== (const T *ptr) const
bool | operator!= (const T *ptr) const
bool | operator< (const T *ptr) const
bool | operator> (const T *ptr) const
T & | operator* () const
T * | operator-> () const
T * | get () const
bool | operator! () const
bool | valid () const

## Protected Attributes

osg::ref_ptr< ObserverSet > | _reference
T * | _ptr

## Detailed Description

template<class T>
class osg::observer_ptr< T >

Smart pointer for observed objects, that automatically set pointers to them to null when they are deleted. To use the observer_ptr<> robustly in multi-threaded applications it is recommend to access the pointer via the lock() method that passes back a ref_ptr<> that safely takes a reference to the object to prevent deletion during usage of the object. In certain conditions it may be safe to use the pointer directly without using lock(), which will confer a performance advantage, the conditions are: 1) The data structure is only accessed/deleted in single threaded/serial way. 2) The data strucutre is guaranteed by high level management of data strucutures and threads which avoid possible situations where the observer_ptr<>'s object may be deleted by one thread whilst being accessed by another. If you are in any doubt about whether it is safe to access the object safe then use the ref_ptr<> observer_ptr<>.lock() combination.

## Member Typedef Documentation

## element_type

template<class T>

typedef T osg::observer_ptr< T >::element_type

## Constructor & Destructor Documentation

## observer_ptr() [1/4]

template<class T>

osg::observer_ptr< T >::observer_ptr | ( |  | ) |

inline

## observer_ptr() [2/4]

template<class T>

osg::observer_ptr< T >::observer_ptr | ( | const ref_ptr< T > & | rp | ) |

inline

Create a observer_ptr from a ref_ptr.

## observer_ptr() [3/4]

template<class T>

osg::observer_ptr< T >::observer_ptr | ( | T * | rp | ) |

inline

Create a observer_ptr from a raw pointer. For compatibility; the result might not be lockable.

## observer_ptr() [4/4]

template<class T>

osg::observer_ptr< T >::observer_ptr | ( | const observer_ptr< T > & | wp | ) |

inline

## ~observer_ptr()

template<class T>

osg::observer_ptr< T >::~observer_ptr | ( |  | ) |

inline

## Member Function Documentation

## get()

template<class T>

T * osg::observer_ptr< T >::get | ( |  | ) | const

inline

Referenced by osg::observer_ptr< object_type >::operator!(), and osg::observer_ptr< object_type >::valid().

## lock()

template<class T>

bool osg::observer_ptr< T >::lock | ( | ref_ptr< T > & | rptr | ) | const

inline

Assign the observer_ptr to a ref_ptr. The ref_ptr will be valid if the referenced object hasn't been deleted and has a ref count > 0.

Referenced by osg::ref_ptr< osg::Vec3Array >::ref_ptr().

## operator!()

template<class T>

bool osg::observer_ptr< T >::operator! | ( |  | ) | const

inline

## operator!=() [1/2]

template<class T>

bool osg::observer_ptr< T >::operator!= | ( | const observer_ptr< T > & | wp | ) | const

inline

## operator!=() [2/2]

template<class T>

bool osg::observer_ptr< T >::operator!= | ( | const T * | ptr | ) | const

inline

## operator*()

template<class T>

T & osg::observer_ptr< T >::operator* | ( |  | ) | const

inline

## operator->()

template<class T>

T * osg::observer_ptr< T >::operator-> | ( |  | ) | const

inline

## operator<() [1/2]

template<class T>

bool osg::observer_ptr< T >::operator< | ( | const observer_ptr< T > & | wp | ) | const

inline

## operator<() [2/2]

template<class T>

bool osg::observer_ptr< T >::operator< | ( | const T * | ptr | ) | const

inline

## operator=() [1/3]

template<class T>

observer_ptr & osg::observer_ptr< T >::operator= | ( | const observer_ptr< T > & | wp | ) |

inline

## operator=() [2/3]

template<class T>

observer_ptr & osg::observer_ptr< T >::operator= | ( | const ref_ptr< T > & | rp | ) |

inline

## operator=() [3/3]

template<class T>

observer_ptr & osg::observer_ptr< T >::operator= | ( | T * | rp | ) |

inline

## operator==() [1/2]

template<class T>

bool osg::observer_ptr< T >::operator== | ( | const observer_ptr< T > & | wp | ) | const

inline

Comparison operators. These continue to work even after the observed object has been deleted.

## operator==() [2/2]

template<class T>

bool osg::observer_ptr< T >::operator== | ( | const T * | ptr | ) | const

inline

## operator>() [1/2]

template<class T>

bool osg::observer_ptr< T >::operator> | ( | const observer_ptr< T > & | wp | ) | const

inline

## operator>() [2/2]

template<class T>

bool osg::observer_ptr< T >::operator> | ( | const T * | ptr | ) | const

inline

## valid()

template<class T>

bool osg::observer_ptr< T >::valid | ( |  | ) | const

inline

## Member Data Documentation

## _ptr

template<class T>

T* osg::observer_ptr< T >::_ptr

protected

Referenced by osg::observer_ptr< object_type >::operator=().

## _reference

template<class T>

osg::ref_ptr<ObserverSet> osg::observer_ptr< T >::_reference

protected

Referenced by osg::observer_ptr< object_type >::operator!=(), osg::observer_ptr< object_type >::operator<(), osg::observer_ptr< object_type >::operator=(), osg::observer_ptr< object_type >::operator==(), and osg::observer_ptr< object_type >::operator>().

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

- observer_ptr