|
| handle () |
| Empty constructor.
|
|
| handle (const T *thePtr) |
| Constructor from pointer to new object.
|
|
| handle (const handle &theHandle) |
| Copy constructor.
|
|
| handle (handle &&theHandle) Standard_Noexcept |
| Move constructor.
|
|
| ~handle () |
| Destructor.
|
|
void | Nullify () |
| Nullify the handle.
|
|
bool | IsNull () const |
| Check for being null.
|
|
void | reset (T *thePtr) |
| Reset by new pointer.
|
|
handle & | operator= (const handle &theHandle) |
| Assignment operator.
|
|
handle & | operator= (const T *thePtr) |
| Assignment to pointer.
|
|
handle & | operator= (handle &&theHandle) Standard_Noexcept |
| Move operator.
|
|
T * | get () const |
| STL-like cast to pointer to referred object (note non-const).
|
|
T * | operator-> () const |
| Member access operator (note non-const)
|
|
T & | operator* () const |
| Dereferencing operator (note non-const)
|
|
template<class T2 > |
bool | operator== (const handle< T2 > &theHandle) const |
| Check for equality.
|
|
template<class T2 > |
bool | operator== (const T2 *thePtr) const |
| Check for equality.
|
|
template<class T2 > |
bool | operator!= (const handle< T2 > &theHandle) const |
| Check for inequality.
|
|
template<class T2 > |
bool | operator!= (const T2 *thePtr) const |
| Check for inequality.
|
|
template<class T2 > |
bool | operator< (const handle< T2 > &theHandle) const |
| Compare operator for possible use in std::map<> etc.
|
|
| operator Standard_Transient *handle::* () const |
| Conversion to bool-compatible type for use in conditional expressions.
|
|
template<class T2 > |
| operator const handle< T2 > & () const |
| Upcast to const reference to base type. NB: this implementation will cause ambiguity errors on calls to overloaded functions accepting handles to different types, since compatibility is checked in the cast code rather than ensured by SFINAE (possible with C++11)
|
|
template<class T2 > |
| operator handle< T2 > & () |
| Upcast to non-const reference to base type. NB: this cast can be dangerous, but required for legacy code; see #26377.
|
|
|
template<class T2 > |
static opencascade::std::enable_if< is_base_but_not_same< T2, T >::value, handle >::type | DownCast (const handle< T2 > &theObject) |
| Down casting operator from handle to base type.
|
|
template<class T2 > |
static opencascade::std::enable_if< is_base_but_not_same< T2, T >::value, handle >::type | DownCast (const T2 *thePtr) |
| Down casting operator from pointer to base type.
|
|
template<class T2 > |
static handle | DownCast (const handle< T2 > &theObject, typename opencascade::std::enable_if<!is_base_but_not_same< T2, T >::value, void * >::type=0) |
| For compatibility, define down casting operator from non-base type, as deprecated.
|
|
template<class T2 > |
static handle | DownCast (const T2 *thePtr, typename opencascade::std::enable_if<!is_base_but_not_same< T2, T >::value, void * >::type=0) |
| For compatibility, define down casting operator from non-base type, as deprecated.
|
|
template<class T>
class opencascade::handle< T >
Intrusive smart pointer for use with Standard_Transient class and its descendants.
This class is similar to boost::intrusive_ptr<>. The reference counter is part of the base class (Standard_Transient), thus creation of a handle does not require allocation of additional memory for the counter. All handles to the same object share the common counter; object is deleted when the last handle pointing on it is destroyed. It is safe to create a new handle from plain C pointer to the object already pointed by another handle. The same object can be referenced by handles of different types (as soon as they are compatible with the object type).
Handle has type cast operator to const reference to handle to the base types, which allows it to be passed by reference in functions accepting reference to handle to base class, without copying.
By default, the type cast operator is provided also for non-const reference. These casts (potentially unsafe) can be disabled by defining macro OCCT_HANDLE_NOCAST; if it is defined, generalized copy constructor and assignment operators are defined allowing to initialize handle of base type from handle to derived type.
Weak pointers are not supported.