17 #ifndef ZORBA_UNIQUE_PTR_H
18 #define ZORBA_UNIQUE_PTR_H
20 #include <zorba/config.h>
22 #ifdef ZORBA_HAVE_UNIQUE_PTR
35 template<
typename T>
inline
36 typename enable_if<!zorba::internal::is_movable<T>::value,T&>
::type
41 template<
typename T>
inline
42 typename enable_if<zorba::internal::is_movable<T>::value,
48 template<
typename T>
inline
49 typename enable_if<zorba::internal::is_movable<T>::value,
64 template<typename T,typename D,bool = ZORBA_TR1_NS::is_empty<D>::value>
75 ptr_( p ), deleter_( d )
101 template<
typename T,
typename D>
136 template<
typename T,
typename D,
bool IsEmpty>
inline
162 typename enable_if<ZORBA_TR1_NS::is_convertible<U*,T*>::value>::
type* = 0 )
201 template<
typename T,
class D = default_delete<T> >
207 deleter_const_reference;
260 template<
typename U,
typename E>
265 ZORBA_TR1_NS::is_convertible<E,D>::value && (
266 !ZORBA_TR1_NS::is_reference<D>::value ||
267 ZORBA_TR1_NS::is_same<D,E>::value
292 reset( p.release() );
307 template<
typename U,
typename E>
309 reset( p.release() );
348 return storage_.
ptr_;
389 if ( p != storage_.
ptr_ ) {
417 void call_deleter() {
419 get_deleter()( storage_.ptr_ );
423 unique_ptr( unique_ptr& );
424 unique_ptr& operator=( unique_ptr& );
425 template<
typename U,
typename E> unique_ptr( unique_ptr<U,E>& );
426 template<
typename U,
typename E> unique_ptr& operator=( unique_ptr<U,E>& );
429 operator ::zorba::internal::rv<unique_ptr>&()
throw() {
433 operator ::zorba::internal::rv<unique_ptr>
const&()
const throw() {
450 template<
typename T,
typename D>
456 deleter_const_reference;
476 reset( p.release() );
477 storage_.deleter() =
move( p.get_deleter() );
482 return storage_.ptr_;
490 return storage_.deleter();
494 return storage_.deleter();
504 if ( p != storage_.ptr_ ) {
515 return explicit_bool::value_of(
get() );
521 void call_deleter() {
523 get_deleter()( storage_.ptr_ );
527 unique_ptr( unique_ptr& );
528 unique_ptr& operator=( unique_ptr& );
529 template<
typename U,
typename E> unique_ptr( unique_ptr<U,E>& );
530 template<
typename U,
typename E> unique_ptr& operator=( unique_ptr<U,E>& );
533 operator ::zorba::internal::rv<unique_ptr>&()
throw() {
537 operator ::zorba::internal::rv<unique_ptr>
const&()
const throw() {
544 #define ZORBA_UNIQUE_PTR_RELOP(OP) \
545 template<typename T1,typename D1,typename T2,typename D2> inline \
546 bool operator OP( unique_ptr<T1,D1> const &a, unique_ptr<T2,D2> const &b ) { \
547 return a.get() OP b.get(); \
557 #undef ZORBA_UNIQUE_PTR_RELOP
569 template<
typename T,
typename D>
inline
static std::enable_if< ZORBA_TR1_NS::is_convertible< T, bool >::value, type >::type value_of(T const &value)
Converts the given value to an explicit bool value.
unique_ptr(pointer p=0)
Default constructor.
unique_ptr_storage(T *p, D &d)
pointer release()
Releases ownership of the pointed-to object.
unique_ptr & operator=(zorba::internal::rv< unique_ptr > &p)
Destructive assignment: moves ownership of the object pointed-to by p to this unique_ptr.
unique_ptr(zorba::internal::rv< unique_ptr > &p)
Constructs a unique_ptr from an existing unique_ptr.
unique_ptr_storage(T *p, deleter_reference d)
void swap(unique_ptr &p)
Swaps the pointer and deleter with that of another unique_ptr.
void operator()(T *p) const
void reset(pointer p=0)
Sets the pointer to the given value or null if none.
unique_ptr(pointer p, deleter_reference d)
Constructs a unique_ptr using a specific deleter.
deleter_reference deleter()
unique_ptr & operator=(zorba::internal::rv< unique_ptr< U, E > > &p)
Destructive assignment: moves ownership of the object pointed-to by p to this unique_ptr.
unique_ptr(pointer p, deleter_reference d)
void operator()(T *p) const
Deletes the pointed-to object using delete.
int pointer_conversion::* type
Helper class for implementing a solution to the "explicit bool conversion" problem.
enable_if< zorba::internal::is_movable< T >::value, zorba::internal::rv< T > & >::type move(zorba::internal::rv< T > &t)
deleter_const_reference get_deleter() const
void swap(unique_ptr_storage< T, D, IsEmpty > &a, unique_ptr_storage< T, D, IsEmpty > &b)
#define ZORBA_UNIQUE_PTR_RELOP(OP)
~unique_ptr()
Destroys the pointed-to object by calling the deleter (if the pointer is not null).
deleter_reference get_deleter()
Gets the deleter in use.
unique_ptr & operator=(int)
Assignment from null: equivalent to reset().
enable_if<!zorba::internal::is_movable< T >::value, T & >::type move(T &t)
deleter_reference get_deleter()
element_type & operator*() const
Dereferences the pointer.
unique_ptr(zorba::internal::rv< unique_ptr< U, E > > &p, typename enable_if< ZORBA_TR1_NS::is_convertible< typename unique_ptr< U >::pointer, pointer >::value &&ZORBA_TR1_NS::is_convertible< E, D >::value &&(!ZORBA_TR1_NS::is_reference< D >::value||ZORBA_TR1_NS::is_same< D, E >::value) >::type *=0)
Constructs a unique_ptr from an existing unique_ptr.
default_delete(default_delete< U > const &, typename enable_if< ZORBA_TR1_NS::is_convertible< U *, T * >::value >::type *=0)
Copy constructor.
void swap(uuid &u1, uuid &u2)
Swaps two UUIDs' data.
unique_ptr & operator=(zorba::internal::rv< unique_ptr > &p)
pointer operator->() const
Gets the pointer.
T & operator[](size_t i) const
deleter_const_reference get_deleter() const
Gets the deleter in use.