PtrTypes.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_PTRTYPES_H
#define ZYPP_BASE_PTRTYPES_H

#include <string>

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/intrusive_ptr.hpp>

namespace zypp
{ 


    struct NullDeleter
    {
      void operator()( const void *const ) const
      {}
    };

    using boost::scoped_ptr;

    using boost::shared_ptr;

    using boost::weak_ptr;

    using boost::intrusive_ptr;

    using boost::static_pointer_cast;
    using boost::const_pointer_cast;
    using boost::dynamic_pointer_cast;

} // namespace zypp
namespace std
{ 

  // namespace sub {
  //    class Foo;
  //    typedef zypp::intrusive_ptr<Foo> Foo_Ptr; // see DEFINE_PTR_TYPE(NAME) macro below
  // }

  // Defined in namespace std g++ finds the output operator (König-Lookup),
  // even if we typedef the pointer in a different namespace than ::zypp.
  // Otherwise we had to define an output operator always in the same namespace
  // as the typedef (else g++ will just print the pointer value).

  template<class _D>
  inline std::ostream & operator<<( std::ostream & str, const zypp::shared_ptr<_D> & obj )
  {
    if ( obj )
      return str << *obj;
    return str << std::string("NULL");
  }
  template<class _D>
  inline std::ostream & dumpOn( std::ostream & str, const zypp::shared_ptr<_D> & obj )
  {
    if ( obj )
      return dumpOn( str, *obj );
    return str << std::string("NULL");
  }

  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");
  }
  template<class _D>
  inline std::ostream & dumpOn( std::ostream & str, const zypp::intrusive_ptr<_D> & obj )
  {
    if ( obj )
      return dumpOn( str, *obj );
    return str << std::string("NULL");
  }
} // namespace std
namespace zypp
{ 

    //
    //  RW_pointer traits
    //

    namespace rw_pointer {

      template<class _D>
        struct Shared
        {
          typedef shared_ptr<_D>       _Ptr;
          typedef shared_ptr<const _D> _constPtr;
          bool unique( const _constPtr & ptr_r )
          { return !ptr_r || ptr_r.unique(); }
          bool unique( const _Ptr & ptr_r )
          { return !ptr_r || ptr_r.unique(); }
          long use_count( const _constPtr & ptr_r ) const
          { return ptr_r.use_count(); }
          long use_count( const _Ptr & ptr_r ) const
          { return ptr_r.use_count(); }
        };

      template<class _D>
        struct Intrusive
        {
          typedef intrusive_ptr<_D>       _Ptr;
          typedef intrusive_ptr<const _D> _constPtr;
          bool unique( const _constPtr & ptr_r )
          { return !ptr_r || (ptr_r->refCount() <= 1); }
          bool unique( const _Ptr & ptr_r )
          { return !ptr_r || (ptr_r->refCount() <= 1); }
          long use_count( const _constPtr & ptr_r ) const
          { return ptr_r ? ptr_r->refCount() : 0; }
          long use_count( const _Ptr & ptr_r ) const
          { return ptr_r ? ptr_r->refCount() : 0; }
        };

       template<class _D>
        struct Scoped
        {
          typedef scoped_ptr<_D>       _Ptr;
          typedef scoped_ptr<const _D> _constPtr;
          bool unique( const _constPtr & ptr_r )
          { return true; }
          bool unique( const _Ptr & ptr_r )
          { return true; }
          long use_count( const _constPtr & ptr_r ) const
          { return ptr_r ? 1 : 0; }
          long use_count( const _Ptr & ptr_r ) const
          { return ptr_r ? 1 : 0; }
        };

   }

    //
    //  CLASS NAME : RW_pointer
    //
    template<class _D, class _Traits = rw_pointer::Shared<_D> >
      struct RW_pointer
      {
        typedef typename _Traits::_Ptr               _Ptr;
        typedef typename _Traits::_constPtr          _constPtr;

        RW_pointer()
        {}

        RW_pointer( std::nullptr_t )
        {}

        explicit
        RW_pointer( typename _Ptr::element_type * dptr )
        : _dptr( dptr )
        {}

        explicit
        RW_pointer( _Ptr dptr )
        : _dptr( dptr )
        {}

        RW_pointer & operator=( std::nullptr_t )
        { reset(); return *this; }

        void reset()
        { _Ptr().swap( _dptr ); }

        void reset( typename _Ptr::element_type * dptr )
        { _Ptr( dptr ).swap( _dptr ); }

        void swap( RW_pointer & rhs )
        { _dptr.swap( rhs._dptr ); }

        void swap( _Ptr & rhs )
        { _dptr.swap( rhs ); }

        explicit operator bool() const
        { return _dptr.get() != nullptr; }

        const _D & operator*() const
        { return *_dptr; };

        const _D * operator->() const
        { return _dptr.operator->(); }

        const _D * get() const
        { return _dptr.get(); }

        _D & operator*()
        { return *_dptr; }

        _D * operator->()
        { return _dptr.operator->(); }

        _D * get()
        { return _dptr.get(); }

      public:
        bool unique() const
        { return _Traits().unique( _dptr ); }

        long use_count() const
        { return _Traits().use_count( _dptr ); }

        _constPtr getPtr() const
        { return _dptr; }

        _Ptr getPtr()
        { return _dptr; }

        _constPtr cgetPtr()
        { return _dptr; }

      private:
        _Ptr _dptr;
      };

    template<class _D, class _Ptr>
      inline std::ostream & operator<<( std::ostream & str, const RW_pointer<_D, _Ptr> & obj )
      {
        if ( obj.get() )
          return str << *obj.get();
        return str << std::string("NULL");
      }

    template<class _D, class _Ptr>
      inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const typename _Ptr::_Ptr & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const typename _Ptr::_constPtr & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
      { return( lhs.get() == nullptr ); }
    template<class _D, class _Ptr>
      inline bool operator==( std::nullptr_t, const RW_pointer<_D, _Ptr> & rhs )
      { return( nullptr == rhs.get() ); }


    template<class _D, class _Ptr>
      inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const typename _Ptr::_Ptr & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const typename _Ptr::_constPtr & lhs, const RW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
      { return( lhs.get() != nullptr ); }
    template<class _D, class _Ptr>
      inline bool operator!=( std::nullptr_t, const RW_pointer<_D, _Ptr> & rhs )
      { return( nullptr != rhs.get() ); }


    template<class _D>
      inline _D * rwcowClone( const _D * rhs )
      { return rhs->clone(); }

    //
    //  CLASS NAME : RWCOW_pointer
    //
    template<class _D, class _Traits = rw_pointer::Shared<_D> >
      struct RWCOW_pointer
      {
        typedef typename _Traits::_Ptr               _Ptr;
        typedef typename _Traits::_constPtr          _constPtr;

        RWCOW_pointer()
        {}

        RWCOW_pointer( std::nullptr_t )
        {}

        explicit
        RWCOW_pointer( typename _Ptr::element_type * dptr )
        : _dptr( dptr )
        {}

        explicit
        RWCOW_pointer( _Ptr dptr )
        : _dptr( dptr )
        {}

        RWCOW_pointer & operator=( std::nullptr_t )
        { reset(); return *this; }

        void reset()
        { _Ptr().swap( _dptr ); }

        void reset( typename _Ptr::element_type * dptr )
        { _Ptr( dptr ).swap( _dptr ); }

        void swap( RWCOW_pointer & rhs )
        { _dptr.swap( rhs._dptr ); }

        void swap( _Ptr & rhs )
        { _dptr.swap( rhs ); }

        explicit operator bool() const
        { return _dptr.get() != nullptr; }

        const _D & operator*() const
        { return *_dptr; };

        const _D * operator->() const
        { return _dptr.operator->(); }

        const _D * get() const
        { return _dptr.get(); }

        _D & operator*()
        { assertUnshared(); return *_dptr; }

        _D * operator->()
        { assertUnshared(); return _dptr.operator->(); }

        _D * get()
        { assertUnshared(); return _dptr.get(); }

      public:
        bool unique() const
        { return _Traits().unique( _dptr ); }

        long use_count() const
        { return _Traits().use_count( _dptr ); }

        _constPtr getPtr() const
        { return _dptr; }

        _Ptr getPtr()
        { assertUnshared(); return _dptr; }

        _constPtr cgetPtr()
        { return _dptr; }

      private:

        void assertUnshared()
        {
          if ( !unique() )
            _Ptr( rwcowClone( _dptr.get() ) ).swap( _dptr );
        }

      private:
        _Ptr _dptr;
      };

    template<class _D, class _Ptr>
      inline std::ostream & operator<<( std::ostream & str, const RWCOW_pointer<_D, _Ptr> & obj )
      {
        if ( obj.get() )
          return str << *obj.get();
        return str << std::string("NULL");
      }

    template<class _D, class _Ptr>
      inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const typename _Ptr::_Ptr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const typename _Ptr::_constPtr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return( lhs.get() == rhs.get() ); }
    template<class _D, class _Ptr>
      inline bool operator==( const RWCOW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
      { return( lhs.get() == nullptr ); }
    template<class _D, class _Ptr>
      inline bool operator==( std::nullptr_t, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return( nullptr == rhs.get() ); }

    template<class _D, class _Ptr>
      inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_Ptr & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const typename _Ptr::_Ptr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, const typename _Ptr::_constPtr & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const typename _Ptr::_constPtr & lhs, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return ! ( lhs == rhs ); }
    template<class _D, class _Ptr>
      inline bool operator!=( const RWCOW_pointer<_D, _Ptr> & lhs, std::nullptr_t )
      { return( lhs.get() != nullptr ); }
    template<class _D, class _Ptr>
      inline bool operator!=( std::nullptr_t, const RWCOW_pointer<_D, _Ptr> & rhs )
      { return( nullptr != rhs.get() ); }


} // namespace zypp

#define DEFINE_PTR_TYPE(NAME) \
class NAME;                                                      \
extern void intrusive_ptr_add_ref( const NAME * );               \
extern void intrusive_ptr_release( const NAME * );               \
typedef zypp::intrusive_ptr<NAME>       NAME##_Ptr;        \
typedef zypp::intrusive_ptr<const NAME> NAME##_constPtr;

#endif // ZYPP_BASE_PTRTYPES_H