/usr/include/osg/ref_ptr is in libopenscenegraph-dev 3.2.1-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | /* -*-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>
namespace osg {
template<typename T> class observer_ptr;
/** Smart pointer for handling referenced counted objects.*/
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 implmentation 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 { return *_ptr; }
T* operator->() const { 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
|