ref_ptr
Go to the documentation of this file.
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_REF_PTR
#define OSG_REF_PTR 1
#include <osg/Config>
#ifdef OSG_USE_REF_PTR_SAFE_DEREFERENCE
#include <typeinfo>
#include <stdexcept>
#include <string>
#endif
namespace osg {
template<typename T> class observer_ptr;
template<class T>
class ref_ptr
{
public:
typedef T element_type;
ref_ptr() : _ptr(0) {}
ref_ptr(T* ptr) : _ptr(ptr) { if (_ptr) _ptr->ref(); }
ref_ptr(const ref_ptr& rp) : _ptr(rp._ptr) { if (_ptr) _ptr->ref(); }
template<class Other> ref_ptr(const ref_ptr<Other>& rp) : _ptr(rp._ptr) { if (_ptr) _ptr->ref(); }
ref_ptr(observer_ptr<T>& optr) : _ptr(0) { optr.lock(*this); }
~ref_ptr() { if (_ptr) _ptr->unref(); _ptr = 0; }
ref_ptr& operator = (const ref_ptr& rp)
{
assign(rp);
return *this;
}
template<class Other> ref_ptr& operator = (const ref_ptr<Other>& rp)
{
assign(rp);
return *this;
}
inline ref_ptr& operator = (T* ptr)
{
if (_ptr==ptr) return *this;
T* tmp_ptr = _ptr;
_ptr = ptr;
if (_ptr) _ptr->ref();
// unref second to prevent any deletion of any object which might
// be referenced by the other object. i.e rp is child of the
// original _ptr.
if (tmp_ptr) tmp_ptr->unref();
return *this;
}
#ifdef OSG_USE_REF_PTR_IMPLICIT_OUTPUT_CONVERSION
// implicit output conversion
operator T*() const { return _ptr; }
#else
// comparison operators for ref_ptr.
bool operator == (const ref_ptr& rp) const { return (_ptr==rp._ptr); }
bool operator == (const T* ptr) const { return (_ptr==ptr); }
friend bool operator == (const T* ptr, const ref_ptr& rp) { return (ptr==rp._ptr); }
bool operator != (const ref_ptr& rp) const { return (_ptr!=rp._ptr); }
bool operator != (const T* ptr) const { return (_ptr!=ptr); }
friend bool operator != (const T* ptr, const ref_ptr& rp) { return (ptr!=rp._ptr); }
bool operator < (const ref_ptr& rp) const { return (_ptr<rp._ptr); }
// follows is an implementation of the "safe bool idiom", details can be found at:
// http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool
// http://lists.boost.org/Archives/boost/2003/09/52856.php
private:
typedef T* ref_ptr::*unspecified_bool_type;
public:
// safe bool conversion
operator unspecified_bool_type() const { return valid()? &ref_ptr::_ptr : 0; }
#endif
T& operator*() const
{
#ifdef OSG_USE_REF_PTR_SAFE_DEREFERENCE
if( !_ptr ) {
// pointer is invalid, so throw an exception
throw std::runtime_error(std::string("could not dereference invalid osg pointer ") + std::string(typeid(T).name()));
}
#endif
return *_ptr;
}
T* operator->() const
{
#ifdef OSG_USE_REF_PTR_SAFE_DEREFERENCE
if( !_ptr ) {
// pointer is invalid, so throw an exception.
throw std::runtime_error(std::string("could not call invalid osg pointer ") + std::string(typeid(T).name()));
}
#endif
return _ptr;
}
T* get() const { return _ptr; }
bool operator!() const { return _ptr==0; } // not required
bool valid() const { return _ptr!=0; }
T* release() { T* tmp=_ptr; if (_ptr) _ptr->unref_nodelete(); _ptr=0; return tmp; }
void swap(ref_ptr& rp) { T* tmp=_ptr; _ptr=rp._ptr; rp._ptr=tmp; }
private:
template<class Other> void assign(const ref_ptr<Other>& rp)
{
if (_ptr==rp._ptr) return;
T* tmp_ptr = _ptr;
_ptr = rp._ptr;
if (_ptr) _ptr->ref();
// unref second to prevent any deletion of any object which might
// be referenced by the other object. i.e rp is child of the
// original _ptr.
if (tmp_ptr) tmp_ptr->unref();
}
template<class Other> friend class ref_ptr;
T* _ptr;
};
template<class T> inline
void swap(ref_ptr<T>& rp1, ref_ptr<T>& rp2) { rp1.swap(rp2); }
template<class T> inline
T* get_pointer(const ref_ptr<T>& rp) { return rp.get(); }
template<class T, class Y> inline
ref_ptr<T> static_pointer_cast(const ref_ptr<Y>& rp) { return static_cast<T*>(rp.get()); }
template<class T, class Y> inline
ref_ptr<T> dynamic_pointer_cast(const ref_ptr<Y>& rp) { return dynamic_cast<T*>(rp.get()); }
template<class T, class Y> inline
ref_ptr<T> const_pointer_cast(const ref_ptr<Y>& rp) { return const_cast<T*>(rp.get()); }
}
#endif
osg::Referenced::unref_nodelete
int unref_nodelete() const
osg::observer_ptr
Definition observer_ptr:39
osg::observer_ptr::lock
bool lock(ref_ptr< T > &rptr) const
Definition observer_ptr:100
osg::ref_ptr
Definition ref_ptr:32
osg::ref_ptr::ref_ptr
friend class ref_ptr
Definition ref_ptr:144
osg::ref_ptr::operator<
bool operator<(const ref_ptr &rp) const
Definition ref_ptr:81
osg::ref_ptr::get
T * get() const
Definition ref_ptr:117
osg::ref_ptr::operator!
bool operator!() const
Definition ref_ptr:119
osg::ref_ptr::swap
void swap(ref_ptr &rp)
Definition ref_ptr:128
osg::ref_ptr::operator->
T * operator->() const
Definition ref_ptr:106
osg::ref_ptr::operator!=
bool operator!=(const ref_ptr &rp) const
Definition ref_ptr:77
osg::ref_ptr::ref_ptr
ref_ptr(const ref_ptr< Other > &rp)
Definition ref_ptr:39
osg::ref_ptr::ref_ptr
ref_ptr(const ref_ptr &rp)
Definition ref_ptr:38
osg::ref_ptr::ref_ptr
ref_ptr(T *ptr)
Definition ref_ptr:37
osg::ref_ptr::ref_ptr
ref_ptr()
Definition ref_ptr:36
osg::ref_ptr::operator=
ref_ptr & operator=(const ref_ptr &rp)
Definition ref_ptr:43
osg::ref_ptr::element_type
T element_type
Definition ref_ptr:34
osg::ref_ptr::~ref_ptr
~ref_ptr()
Definition ref_ptr:41
osg::ref_ptr::release
T * release()
Definition ref_ptr:126
osg::ref_ptr::operator==
bool operator==(const ref_ptr &rp) const
Definition ref_ptr:73
osg::ref_ptr::ref_ptr
ref_ptr(observer_ptr< T > &optr)
Definition ref_ptr:40
osg::ref_ptr::operator*
T & operator*() const
Definition ref_ptr:96
osg::ref_ptr::valid
bool valid() const
Definition ref_ptr:120
osg
Definition AlphaFunc:19
osg::static_pointer_cast
ref_ptr< T > static_pointer_cast(const ref_ptr< Y > &rp)
Definition ref_ptr:157
osg::get_pointer
T * get_pointer(const ref_ptr< T > &rp)
Definition ref_ptr:154
osg::swap
void swap(MixinVector< ValueT > &left, MixinVector< ValueT > &right)
Definition MixinVector:174
osg::const_pointer_cast
ref_ptr< T > const_pointer_cast(const ref_ptr< Y > &rp)
Definition ref_ptr:163
osg::dynamic_pointer_cast
ref_ptr< T > dynamic_pointer_cast(const ref_ptr< Y > &rp)
Definition ref_ptr:160