PtrTypes.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_PTRTYPES_H
#define ZYPP_BASE_PTRTYPES_H
 
#include <iosfwd>
#include <string>
 
#include <zypp-core/Globals.h>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/intrusive_ptr.hpp>

namespace zypp
{ 
 
  namespace str
  {
    // printing void* (prevents us from including <ostream>)
    std::string form( const char * format, ... ) __attribute__ ((format (printf, 1, 2)));
  }


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

    using boost::scoped_ptr;

    using boost::shared_ptr;

    using boost::weak_ptr;

    using boost::intrusive_ptr;
 
    template<typename T, typename... Args>
    inline intrusive_ptr<T>
    make_intrusive( Args&&... __args ) {
      return intrusive_ptr<T>( new T( std::forward<Args>(__args)...) );
    }

    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<>
  inline std::ostream & operator<<( std::ostream & str, const zypp::shared_ptr<void> & obj )
  {
    if ( obj )
      return str << zypp::str::form( "%p", static_cast<void*>(obj.get()) );
    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<>
  inline std::ostream & dumpOn( std::ostream & str, const zypp::shared_ptr<void> & obj )
  { return str << 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");
  }
  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
        {
          using PtrType = shared_ptr<D>;
          using constPtrType = shared_ptr<const D>;
          bool unique( const constPtrType & ptr_r )
          { return !ptr_r || ptr_r.unique(); }
          bool unique( const PtrType & ptr_r )
          { return !ptr_r || ptr_r.unique(); }

          long use_count( const constPtrType & ptr_r ) const
          { return ptr_r.use_count(); }
          long use_count( const PtrType & ptr_r ) const
          { return ptr_r.use_count(); }
        };
 
      template<class D>
        struct Intrusive
        {
          using PtrType = intrusive_ptr<D>;
          using constPtrType = intrusive_ptr<const D>;
          bool unique( const constPtrType & ptr_r )
          { return !ptr_r || (ptr_r->refCount() <= 1); }
          bool unique( const PtrType & ptr_r )
          { return !ptr_r || (ptr_r->refCount() <= 1); }

          long use_count( const constPtrType & ptr_r ) const
          { return ptr_r ? ptr_r->refCount() : 0; }
          long use_count( const PtrType & ptr_r ) const
          { return ptr_r ? ptr_r->refCount() : 0; }
        };
 
       template<class D>
        struct Scoped
        {
          using PtrType = scoped_ptr<D>;
          using constPtrType = scoped_ptr<const D>;
          bool unique( const constPtrType & ptr_r )
          { return true; }
          bool unique( const PtrType & ptr_r )
          { return true; }

          long use_count( const constPtrType & ptr_r ) const
          { return ptr_r ? 1 : 0; }
          long use_count( const PtrType & ptr_r ) const
          { return ptr_r ? 1 : 0; }
        };
 
   }


    //
    //  CLASS NAME : RW_pointer
    //
    template<class D, class DTraits = rw_pointer::Shared<D> >
      struct RW_pointer
      {
        using PtrType = typename DTraits::PtrType;
        using constPtrType = typename DTraits::constPtrType;
 
        RW_pointer()
        {}
 
        RW_pointer(const RW_pointer &) = default;
        RW_pointer(RW_pointer &&) = default;
        RW_pointer &operator=(const RW_pointer &) = default;
        RW_pointer &operator=(RW_pointer &&) = default;
        RW_pointer(std::nullptr_t) {}
 
        explicit
        RW_pointer( typename PtrType::element_type * dptr )
        : _dptr( dptr )
        {}
 
        explicit
        RW_pointer( PtrType dptr )
        : _dptr( dptr )
        {}
 
        RW_pointer & operator=( std::nullptr_t )
        { reset(); return *this; }
 
        void reset()
        { PtrType().swap( _dptr ); }
 
        void reset( typename PtrType::element_type * dptr )
        { PtrType( dptr ).swap( _dptr ); }
 
        void swap( RW_pointer & rhs ) noexcept
        { _dptr.swap( rhs._dptr ); }
 
        void swap( PtrType & rhs ) noexcept
        { _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 DTraits().unique( _dptr ); }
 
        long use_count() const
        { return DTraits().use_count( _dptr ); }
 
        constPtrType getPtr() const
        { return _dptr; }
 
        PtrType getPtr()
        { return _dptr; }
 
        constPtrType cgetPtr()
        { return _dptr; }
 
      private:
        PtrType _dptr;
      };


    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();
        return str << std::string("NULL");
      }

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

    template<class D, class DPtr>
      inline bool operator==( const RW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const typename DPtr::PtrType & lhs, const RW_pointer<D, DPtr> & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const RW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const typename DPtr::constPtrType & lhs, const RW_pointer<D, DPtr> & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const RW_pointer<D, DPtr> & lhs, std::nullptr_t )
      { return( lhs.get() == nullptr ); }

    template<class D, class DPtr>
      inline bool operator==( std::nullptr_t, const RW_pointer<D, DPtr> & rhs )
      { return( nullptr == rhs.get() ); }
 

    template<class D, class DPtr>
      inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const RW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const typename DPtr::PtrType & lhs, const RW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const typename DPtr::constPtrType & lhs, const RW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RW_pointer<D, DPtr> & lhs, std::nullptr_t )
      { return( lhs.get() != nullptr ); }

    template<class D, class DPtr>
      inline bool operator!=( std::nullptr_t, const RW_pointer<D, DPtr> & 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 DTraits = rw_pointer::Shared<D> >
      struct RWCOW_pointer
      {
        using PtrType = typename DTraits::PtrType;
        using constPtrType = typename DTraits::constPtrType;
 
        RWCOW_pointer() {}
 
        RWCOW_pointer(std::nullptr_t) {}
 
        RWCOW_pointer(const RWCOW_pointer &) = default;
 
        RWCOW_pointer(RWCOW_pointer &&) = default;
 
        explicit
        RWCOW_pointer( typename PtrType::element_type * dptr )
        : _dptr( dptr )
        {}
 
        explicit
        RWCOW_pointer( PtrType dptr )
        : _dptr( dptr )
        {}
 
        RWCOW_pointer & operator=( std::nullptr_t )
        { reset(); return *this; }
 
        RWCOW_pointer &operator=(const RWCOW_pointer &) = default;
 
        RWCOW_pointer &operator=(RWCOW_pointer &&) = default;
 
        void reset()
        { PtrType().swap( _dptr ); }
 
        void reset( typename PtrType::element_type * dptr )
        { PtrType( dptr ).swap( _dptr ); }
 
        void swap( RWCOW_pointer & rhs ) noexcept
        { _dptr.swap( rhs._dptr ); }
 
        void swap( PtrType & rhs ) noexcept
        { _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 DTraits().unique( _dptr ); }
 
        long use_count() const
        { return DTraits().use_count( _dptr ); }
 
        constPtrType getPtr() const
        { return _dptr; }
 
        PtrType getPtr()
        { assertUnshared(); return _dptr; }
 
        constPtrType cgetPtr()
        { return _dptr; }
 
      private:
 
        void assertUnshared()
        {
          if ( !unique() )
            PtrType( rwcowClone( _dptr.get() ) ).swap( _dptr );
        }
 
      private:
        PtrType _dptr;
      };


    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();
        return str << std::string("NULL");
      }

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

    template<class D, class DPtr>
      inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const typename DPtr::PtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const typename DPtr::constPtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
      { return( lhs.get() == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator==( const RWCOW_pointer<D, DPtr> & lhs, std::nullptr_t )
      { return( lhs.get() == nullptr ); }

    template<class D, class DPtr>
      inline bool operator==( std::nullptr_t, const RWCOW_pointer<D, DPtr> & rhs )
      { return( nullptr == rhs.get() ); }

    template<class D, class DPtr>
      inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const RWCOW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::PtrType & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const typename DPtr::PtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, const typename DPtr::constPtrType & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const typename DPtr::constPtrType & lhs, const RWCOW_pointer<D, DPtr> & rhs )
      { return ! ( lhs == rhs ); }

    template<class D, class DPtr>
      inline bool operator!=( const RWCOW_pointer<D, DPtr> & lhs, std::nullptr_t )
      { return( lhs.get() != nullptr ); }

    template<class D, class DPtr>
      inline bool operator!=( std::nullptr_t, const RWCOW_pointer<D, DPtr> & rhs )
      { return( nullptr != rhs.get() ); }


} // namespace zypp

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

#endif // ZYPP_BASE_PTRTYPES_H