// as the typedef (else g++ will just print the pointer value).
/** \relates zypp::shared_ptr Stream output. */
- template<class _D>
- inline std::ostream & operator<<( std::ostream & str, const zypp::shared_ptr<_D> & obj )
+ template<class D>
+ inline std::ostream & operator<<( std::ostream & str, const zypp::shared_ptr<D> & obj )
{
if ( obj )
return str << *obj;
}
/** \relates zypp::shared_ptr Stream output. */
- template<class _D>
- inline std::ostream & dumpOn( std::ostream & str, const zypp::shared_ptr<_D> & obj )
+ template<class D>
+ inline std::ostream & dumpOn( std::ostream & str, const zypp::shared_ptr<D> & obj )
{
if ( obj )
return dumpOn( str, *obj );
{ return str << obj; }
/** \relates zypp::intrusive_ptr Stream output. */
- template<class _D>
- inline std::ostream & operator<<( std::ostream & str, const zypp::intrusive_ptr<_D> & obj )
+ template<class D>
+ inline std::ostream & operator<<( std::ostream & str, const zypp::intrusive_ptr<D> & obj )
{
if ( obj )
return str << *obj;
return str << std::string("NULL");
}
/** \relates zypp::intrusive_ptr Stream output. */
- template<class _D>
- inline std::ostream & dumpOn( std::ostream & str, const zypp::intrusive_ptr<_D> & obj )
+ template<class D>
+ inline std::ostream & dumpOn( std::ostream & str, const zypp::intrusive_ptr<D> & obj )
{
if ( obj )
return dumpOn( str, *obj );
//
///////////////////////////////////////////////////////////////////
/**
- * Don't forgett to provide versions for _Ptr and _constPtr,
+ * Don't forgett to provide versions for PtrType and constPtrType,
* esp. if creation a of temporary is not acceptable (eg. when
* checking the ref count value).
*/
namespace rw_pointer {
- template<class _D>
+ template<class D>
struct Shared
{
- typedef shared_ptr<_D> _Ptr;
- typedef shared_ptr<const _D> _constPtr;
+ typedef shared_ptr<D> PtrType;
+ typedef shared_ptr<const D> constPtrType;
/** Check whether pointer is not shared. */
- bool unique( const _constPtr & ptr_r )
+ bool unique( const constPtrType & ptr_r )
{ return !ptr_r || ptr_r.unique(); }
- bool unique( const _Ptr & ptr_r )
+ bool unique( const PtrType & ptr_r )
{ return !ptr_r || ptr_r.unique(); }
/** Return number of references. */
- long use_count( const _constPtr & ptr_r ) const
+ long use_count( const constPtrType & ptr_r ) const
{ return ptr_r.use_count(); }
- long use_count( const _Ptr & ptr_r ) const
+ long use_count( const PtrType & ptr_r ) const
{ return ptr_r.use_count(); }
};
- template<class _D>
+ template<class D>
struct Intrusive
{
- typedef intrusive_ptr<_D> _Ptr;
- typedef intrusive_ptr<const _D> _constPtr;
+ typedef intrusive_ptr<D> PtrType;
+ typedef intrusive_ptr<const D> constPtrType;
/** Check whether pointer is not shared. */
- bool unique( const _constPtr & ptr_r )
+ bool unique( const constPtrType & ptr_r )
{ return !ptr_r || (ptr_r->refCount() <= 1); }
- bool unique( const _Ptr & ptr_r )
+ bool unique( const PtrType & ptr_r )
{ return !ptr_r || (ptr_r->refCount() <= 1); }
/** Return number of references. */
- long use_count( const _constPtr & ptr_r ) const
+ long use_count( const constPtrType & ptr_r ) const
{ return ptr_r ? ptr_r->refCount() : 0; }
- long use_count( const _Ptr & ptr_r ) const
+ long use_count( const PtrType & ptr_r ) const
{ return ptr_r ? ptr_r->refCount() : 0; }
};
- template<class _D>
+ template<class D>
struct Scoped
{
- typedef scoped_ptr<_D> _Ptr;
- typedef scoped_ptr<const _D> _constPtr;
+ typedef scoped_ptr<D> PtrType;
+ typedef scoped_ptr<const D> constPtrType;
/** Check whether pointer is not shared. */
- bool unique( const _constPtr & ptr_r )
+ bool unique( const constPtrType & ptr_r )
{ return true; }
- bool unique( const _Ptr & ptr_r )
+ bool unique( const PtrType & ptr_r )
{ return true; }
/** Return number of references. */
- long use_count( const _constPtr & ptr_r ) const
+ long use_count( const constPtrType & ptr_r ) const
{ return ptr_r ? 1 : 0; }
- long use_count( const _Ptr & ptr_r ) const
+ long use_count( const PtrType & ptr_r ) const
{ return ptr_r ? 1 : 0; }
};
//
/** Wrapper for \c const correct access via \ref ZYPP_SMART_PTR.
*
- * zypp::RW_pointer<tt>\<_D,_Traits></tt> stores a \ref ZYPP_SMART_PTR
- * of type \c _Traits::_Ptr, which must be convertible into a <tt>_D *</tt>.
- * Pointer style access (via \c -> and \c *) offers a <tt>const _D *</tt> in const
- * a context, otherwise a <tt>_D *</tt>. Thus \em RW_ means \em read/write,
+ * zypp::RW_pointer<tt>\<D,DTraits></tt> stores a \ref ZYPP_SMART_PTR
+ * of type \c DTraits::PtrType, which must be convertible into a <tt>D *</tt>.
+ * Pointer style access (via \c -> and \c *) offers a <tt>const D *</tt> in const
+ * a context, otherwise a <tt>D *</tt>. Thus \em RW_ means \em read/write,
* as you get a different type, dependent on whether you're allowed to
* read or write.
*
* nonconst implementation methods.
*
* The second template argument defaults to
- * <tt>_Traits = rw_pointer::Shared<_D></tt> thus wraping a
- * <tt>shared_ptr<_D></tt>. To wrap an <tt>intrusive_ptr<_D></tt>
- * use <tt>rw_pointer::Intrusive<_D></tt>.
+ * <tt>DTraits = rw_pointer::Shared<D></tt> thus wraping a
+ * <tt>shared_ptr<D></tt>. To wrap an <tt>intrusive_ptr<D></tt>
+ * use <tt>rw_pointer::Intrusive<D></tt>.
*
* \see zypp::RWCOW_pointer for 'copy on write' functionality.
*
* };
* \endcode
*/
- template<class _D, class _Traits = rw_pointer::Shared<_D> >
+ template<class D, class DTraits = rw_pointer::Shared<D> >
struct RW_pointer
{
- typedef typename _Traits::_Ptr _Ptr;
- typedef typename _Traits::_constPtr _constPtr;
+ typedef typename DTraits::PtrType PtrType;
+ typedef typename DTraits::constPtrType constPtrType;
RW_pointer()
{}
{}
explicit
- RW_pointer( typename _Ptr::element_type * dptr )
+ RW_pointer( typename PtrType::element_type * dptr )
: _dptr( dptr )
{}
explicit
- RW_pointer( _Ptr dptr )
+ RW_pointer( PtrType dptr )
: _dptr( dptr )
{}
{ reset(); return *this; }
void reset()
- { _Ptr().swap( _dptr ); }
+ { PtrType().swap( _dptr ); }
- void reset( typename _Ptr::element_type * dptr )
- { _Ptr( dptr ).swap( _dptr ); }
+ void reset( typename PtrType::element_type * dptr )
+ { PtrType( dptr ).swap( _dptr ); }
void swap( RW_pointer & rhs )
{ _dptr.swap( rhs._dptr ); }
- void swap( _Ptr & rhs )
+ void swap( PtrType & rhs )
{ _dptr.swap( rhs ); }
explicit operator bool() const
{ return _dptr.get() != nullptr; }
- const _D & operator*() const
+ const D & operator*() const
{ return *_dptr; };
- const _D * operator->() const
+ const D * operator->() const
{ return _dptr.operator->(); }
- const _D * get() const
+ const D * get() const
{ return _dptr.get(); }
- _D & operator*()
+ D & operator*()
{ return *_dptr; }
- _D * operator->()
+ D * operator->()
{ return _dptr.operator->(); }
- _D * get()
+ D * get()
{ return _dptr.get(); }
public:
bool unique() const
- { return _Traits().unique( _dptr ); }
+ { return DTraits().unique( _dptr ); }
long use_count() const
- { return _Traits().use_count( _dptr ); }
+ { return DTraits().use_count( _dptr ); }
- _constPtr getPtr() const
+ constPtrType getPtr() const
{ return _dptr; }
- _Ptr getPtr()
+ PtrType getPtr()
{ return _dptr; }
- _constPtr cgetPtr()
+ constPtrType cgetPtr()
{ return _dptr; }
private:
- _Ptr _dptr;
+ PtrType _dptr;
};
///////////////////////////////////////////////////////////////////
/** \relates RW_pointer Stream output.
*
- * Print the \c _D object the RW_pointer refers, or \c "NULL"
+ * Print the \c D object the RW_pointer refers, or \c "NULL"
* if the pointer is \c NULL.
*/
- template<class _D, class _Ptr>
- inline std::ostream & operator<<( std::ostream & str, const RW_pointer<_D, _Ptr> & obj )
+ template<class D, class DPtr>
+ inline std::ostream & operator<<( std::ostream & str, const RW_pointer<D, DPtr> & obj )
{
if ( obj.get() )
return str << *obj.get();
}
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RW_pointer<D, DPtr> & lhs, const RW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const typename _Ptr::_Ptr & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const typename DPtr::PtrType & lhs, const RW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const typename _Ptr::_constPtr & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const typename DPtr::constPtrType & lhs, const RW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
+ template<class D, class DPtr>
+ inline bool operator==( const RW_pointer<D, DPtr> & lhs, std::nullptr_t )
{ return( lhs.get() == nullptr ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( std::nullptr_t, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( std::nullptr_t, const RW_pointer<D, DPtr> & rhs )
{ return( nullptr == rhs.get() ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const RW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const typename _Ptr::_Ptr & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const typename DPtr::PtrType & lhs, const RW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const typename _Ptr::_constPtr & lhs, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const typename DPtr::constPtrType & lhs, const RW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
+ template<class D, class DPtr>
+ inline bool operator!=( const RW_pointer<D, DPtr> & lhs, std::nullptr_t )
{ return( lhs.get() != nullptr ); }
/** \relates RW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( std::nullptr_t, const RW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( std::nullptr_t, const RW_pointer<D, DPtr> & rhs )
{ return( nullptr != rhs.get() ); }
///////////////////////////////////////////////////////////////////
/** \relates RWCOW_pointer Clone the underlying object.
* Calls \a rhs <tt>-\>clone()</tt>. Being defined as a
* function outside \ref RWCOW_pointer allows to overload
- * it, in case a specific \a _D does not have <tt>clone()</tt>.
+ * it, in case a specific \a D does not have <tt>clone()</tt>.
*/
- template<class _D>
- inline _D * rwcowClone( const _D * rhs )
+ template<class D>
+ inline D * rwcowClone( const D * rhs )
{ return rhs->clone(); }
///////////////////////////////////////////////////////////////////
*
* See \ref RW_pointer.
*/
- template<class _D, class _Traits = rw_pointer::Shared<_D> >
+ template<class D, class DTraits = rw_pointer::Shared<D> >
struct RWCOW_pointer
{
- typedef typename _Traits::_Ptr _Ptr;
- typedef typename _Traits::_constPtr _constPtr;
+ typedef typename DTraits::PtrType PtrType;
+ typedef typename DTraits::constPtrType constPtrType;
RWCOW_pointer()
{}
{}
explicit
- RWCOW_pointer( typename _Ptr::element_type * dptr )
+ RWCOW_pointer( typename PtrType::element_type * dptr )
: _dptr( dptr )
{}
explicit
- RWCOW_pointer( _Ptr dptr )
+ RWCOW_pointer( PtrType dptr )
: _dptr( dptr )
{}
{ reset(); return *this; }
void reset()
- { _Ptr().swap( _dptr ); }
+ { PtrType().swap( _dptr ); }
- void reset( typename _Ptr::element_type * dptr )
- { _Ptr( dptr ).swap( _dptr ); }
+ void reset( typename PtrType::element_type * dptr )
+ { PtrType( dptr ).swap( _dptr ); }
void swap( RWCOW_pointer & rhs )
{ _dptr.swap( rhs._dptr ); }
- void swap( _Ptr & rhs )
+ void swap( PtrType & rhs )
{ _dptr.swap( rhs ); }
explicit operator bool() const
{ return _dptr.get() != nullptr; }
- const _D & operator*() const
+ const D & operator*() const
{ return *_dptr; };
- const _D * operator->() const
+ const D * operator->() const
{ return _dptr.operator->(); }
- const _D * get() const
+ const D * get() const
{ return _dptr.get(); }
- _D & operator*()
+ D & operator*()
{ assertUnshared(); return *_dptr; }
- _D * operator->()
+ D * operator->()
{ assertUnshared(); return _dptr.operator->(); }
- _D * get()
+ D * get()
{ assertUnshared(); return _dptr.get(); }
public:
bool unique() const
- { return _Traits().unique( _dptr ); }
+ { return DTraits().unique( _dptr ); }
long use_count() const
- { return _Traits().use_count( _dptr ); }
+ { return DTraits().use_count( _dptr ); }
- _constPtr getPtr() const
+ constPtrType getPtr() const
{ return _dptr; }
- _Ptr getPtr()
+ PtrType getPtr()
{ assertUnshared(); return _dptr; }
- _constPtr cgetPtr()
+ constPtrType cgetPtr()
{ return _dptr; }
private:
void assertUnshared()
{
if ( !unique() )
- _Ptr( rwcowClone( _dptr.get() ) ).swap( _dptr );
+ PtrType( rwcowClone( _dptr.get() ) ).swap( _dptr );
}
private:
- _Ptr _dptr;
+ PtrType _dptr;
};
///////////////////////////////////////////////////////////////////
/** \relates RWCOW_pointer Stream output.
*
- * Print the \c _D object the RWCOW_pointer refers, or \c "NULL"
+ * Print the \c D object the RWCOW_pointer refers, or \c "NULL"
* if the pointer is \c NULL.
*/
- template<class _D, class _Ptr>
- inline std::ostream & operator<<( std::ostream & str, const RWCOW_pointer<_D, _Ptr> & obj )
+ template<class D, class DPtr>
+ inline std::ostream & operator<<( std::ostream & str, const RWCOW_pointer<D, DPtr> & obj )
{
if ( obj.get() )
return str << *obj.get();
}
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const typename _Ptr::_Ptr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const typename DPtr::PtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const typename _Ptr::_constPtr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( const typename DPtr::constPtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return( lhs.get() == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
+ template<class D, class DPtr>
+ inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, std::nullptr_t )
{ return( lhs.get() == nullptr ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator==( std::nullptr_t, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator==( std::nullptr_t, const RWCOW_pointer<D, DPtr> & rhs )
{ return( nullptr == rhs.get() ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const typename _Ptr::_Ptr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const typename DPtr::PtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const typename _Ptr::_constPtr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( const typename DPtr::constPtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
{ return ! ( lhs == rhs ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
+ template<class D, class DPtr>
+ inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, std::nullptr_t )
{ return( lhs.get() != nullptr ); }
/** \relates RWCOW_pointer */
- template<class _D, class _Ptr>
- inline bool operator!=( std::nullptr_t, const RWCOW_pointer<_D, _Ptr> & rhs )
+ template<class D, class DPtr>
+ inline bool operator!=( std::nullptr_t, const RWCOW_pointer<D, DPtr> & rhs )
{ return( nullptr != rhs.get() ); }
///////////////////////////////////////////////////////////////////