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;
        typedef typename _Ptr::unspecified_bool_type unspecified_bool_type;

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

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

        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 ); }

        operator unspecified_bool_type() const
        { return _dptr; }

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

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

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

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

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

        _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; }

      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 RW_pointer<_D, _Ptr> & rhs )
      {
        return ! ( lhs == rhs );
      }


    //
    //  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;
        typedef typename _Ptr::unspecified_bool_type unspecified_bool_type;

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

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

        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 ); }

        operator unspecified_bool_type() const
        { return _dptr; }

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

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

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

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

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

        _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; }

      private:

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

      private:
        _Ptr _dptr;
      };

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


    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 RWCOW_pointer<_D, _Ptr> & rhs )
      {
        return ! ( lhs == rhs );
      }



} // 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