Rep.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       Rep.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

   Purpose: Base class for reference counted objects and counted pointer templates.

/-*/
#ifndef Rep_h
#define Rep_h

#include <iosfwd>

//
//      CLASS NAME : Rep
class Rep {
  private:

    mutable unsigned _counter;

  protected:

    virtual void ref_to( unsigned /* rep_cnt_r */ ) const {}
    virtual void unref_to( unsigned /* rep_cnt_r */ ) const {}

  public:

    Rep() : _counter( 0 ) {}
    Rep( const Rep & /* rhs */ ) : _counter( 0 ) {}
    Rep & operator=( const Rep & /* rhs */ ) { return *this; }
    virtual ~Rep() { if ( _counter ) throw( this ); }

  public:

    void ref() const {
      ref_to( ++_counter ); // trigger derived classes
    }
    void unref() const {
      if ( ! _counter )
        throw( this );
      if ( --_counter )
        unref_to( _counter ); // trigger derived classes
      else
        delete this;
    }

    static void ref( const Rep * obj_r ) {
      if ( obj_r )
        obj_r->ref();
    }
    static void unref( const Rep * obj_r ) {
      if ( obj_r )
        obj_r->unref();
    }

  public:

    unsigned refCount() const { return _counter; }

  public:

    virtual const char * repName() const { return "Rep"; }
    virtual std::ostream & dumpOn( std::ostream & str ) const;
};

std::ostream & operator<<( std::ostream & str, const Rep & obj );
std::ostream & operator<<( std::ostream & str, const Rep * obj );


//
//      CLASS NAME : CountedRep
class CountedRep : public Rep {

  private:

    static unsigned _objectCount;
    static unsigned _objectIds;

    const unsigned _objectId;

  public:

    CountedRep() : _objectId( ++_objectIds ) { ++_objectCount; }
    CountedRep( const CountedRep & rhs ) : Rep( rhs ), _objectId( ++_objectIds ) { ++_objectCount; }
    CountedRep & operator=( const CountedRep & rhs ) {
      Rep::operator=( rhs );
      return *this;
    }
    virtual ~CountedRep() { --_objectCount; }

  public:

    unsigned objectId() const { return _objectId; }

    static unsigned objectCount() { return _objectCount; }

  public:

    virtual std::ostream & dumpOn( std::ostream & str ) const;
};


//
// Counted pointer
//

//
//      CLASS NAME : RepPtrStore<typename _Tp, typename _Bt>
template<typename _Tp, typename _Bt = _Tp>
class RepPtrStore {

  private:

    _Tp * _obj;

  private:

    void _assign( _Tp * new_r );

  public:

    RepPtrStore() : _obj( 0 ) {}
    RepPtrStore( _Tp * ptr ) : _obj( 0 ) { _assign( ptr ); }
    RepPtrStore( const RepPtrStore & rhs ) : _obj( 0 ) { _assign( rhs._obj ); }

    RepPtrStore & operator=( _Tp * ptr ) { _assign( ptr ); return *this; }
    RepPtrStore & operator=( const RepPtrStore & rhs ) { _assign( rhs._obj ); return *this; }

    ~RepPtrStore() { _assign( 0 ); }

    operator _Tp *() const { return _obj; }

  public:

    void tryAssign( _Bt * ptr );

  public:

    _Bt * base() const;
    const Rep * refbase() const;
};

template<typename _Tp,typename _Bt>
void RepPtrStore<_Tp,_Bt>::_assign( _Tp * new_r ) {
  if ( new_r != _obj ) {
    Rep::unref( _obj );
    _obj = new_r;
    Rep::ref( _obj );
  }
}

template<typename _Tp,typename _Bt>
void RepPtrStore<_Tp,_Bt>::tryAssign( _Bt * ptr ) {
  _assign( dynamic_cast<_Tp*>(ptr) );
  if ( !_obj && ptr && ! ptr->refCount() ) {
    Rep::ref( ptr );
    Rep::unref( ptr );
  }
}

template<typename _Tp,typename _Bt>
_Bt * RepPtrStore<_Tp,_Bt>::base() const { return _obj; }

template<typename _Tp,typename _Bt>
const Rep * RepPtrStore<_Tp,_Bt>::refbase() const { return _obj; }


//
//      CLASS NAME : RepPtrBase
class RepPtrBase {
  friend std::ostream & operator<<( std::ostream & str, const RepPtrBase & obj );

  protected:

    virtual ~RepPtrBase() {}
    virtual const Rep * refbase() const = 0;

  public:

    operator const void *() const  { return refbase(); }
};


template<typename _Bt> class constPtrBase;

//
//      CLASS NAME : PtrBase<typename _Bt>
template<typename _Bt>
class PtrBase : public RepPtrBase {

  protected:

    friend class constPtrBase<_Bt>;

    virtual _Bt * base() const = 0;

    _Bt * getBase( const PtrBase & rhs ) const {
      return rhs.base();
    }
};


//
//      CLASS NAME : constPtrBase<typename _Bt>
template<typename _Bt>
class constPtrBase : public RepPtrBase {

  protected:

    virtual const _Bt * base() const = 0;

    const _Bt * getBase( const constPtrBase & rhs ) const {
      return rhs.base();
    }

    const _Bt * getBase( const PtrBase<_Bt> & rhs ) const {
      return rhs.base();
    }
};


template<typename _Tp,typename _Bt> class constPtr;

//
//      CLASS NAME : Ptr<typename _Tp, typename _Bt>
template<typename _Tp, typename _Bt = _Tp>
class Ptr : public PtrBase<_Bt> {

  private:

    RepPtrStore<_Tp,_Bt> _ptr;

  protected:

    virtual const Rep * refbase() const { return _ptr.refbase(); }
    virtual _Bt * base() const { return _ptr.base(); }

  public:

    Ptr( _Tp * ptr = 0 ) : _ptr( ptr ) {}
    Ptr( const Ptr & rhs ) : PtrBase<_Bt>( rhs ), _ptr( rhs._ptr ) {}
    Ptr( const PtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); }

  public:

    Ptr & operator=( _Tp * ptr ) { _ptr = ptr; return *this; }
    Ptr & operator=( const Ptr & rhs ) { _ptr = rhs._ptr; return *this; }
    Ptr & operator=( const PtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); return *this; }

  public:

    _Tp * operator->() const { return _ptr; }

    _Tp & operator*() const { return *_ptr; }

  public:

    static Ptr cast_away_const( constPtr<_Tp,_Bt> rhs ) {
      return const_cast<_Tp*>(rhs.operator->());
    }
};


//
//      CLASS NAME : constPtr<typename _Tp, typename _Bt>
template<typename _Tp, typename _Bt = _Tp>
class constPtr : public constPtrBase<_Bt> {

  private:

    RepPtrStore<const _Tp,const _Bt> _ptr;

  protected:

    virtual const Rep * refbase() const { return _ptr.refbase(); }
    virtual const _Bt * base() const { return _ptr.base(); }

  public:

    constPtr( const _Tp * ptr = 0 ) : _ptr( ptr ) {}
    constPtr( const constPtr & rhs ) : constPtrBase<_Bt>( rhs ), _ptr( rhs._ptr ) {}
    constPtr( const constPtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); }

  public:

    constPtr & operator=( const _Tp * ptr ) { _ptr = ptr; return *this; }
    constPtr & operator=( const constPtr & rhs ) { _ptr = rhs._ptr; return *this; }
    constPtr & operator=( const constPtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); return *this; }

  public:

    constPtr( const Ptr<_Tp,_Bt> & rhs ) : _ptr( rhs.operator->() ) {}
    constPtr( const PtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); }

  public:

    constPtr & operator=( const Ptr<_Tp,_Bt> & rhs ) { _ptr = rhs.operator->(); return *this; }
    constPtr & operator=( const PtrBase<_Bt> & rhs ) { _ptr.tryAssign( getBase( rhs ) ); return *this; }

  public:

    const _Tp * operator->() const { return _ptr; }
    const _Tp & operator*() const { return *_ptr; }
};


//
//      CLASS NAME : VarPtr
//

//
//      CLASS NAME : BasicRepPtr
class BasicRepPtr
{
  friend std::ostream &
  operator<<( std::ostream & str, const BasicRepPtr & obj )
  { return str << obj._ptr; }

  public:
    operator const void *() const
    { return _ptr; }

  protected:
    BasicRepPtr()
    : _ptr( NULL )
    {}

    explicit
    BasicRepPtr( Rep * ptr )
    : _ptr( NULL )
    { _assign( ptr ); }

    BasicRepPtr( const BasicRepPtr & rhs )
    : _ptr( NULL )
    { _assign( rhs._ptr ); }

    BasicRepPtr &
    operator=( const BasicRepPtr & rhs )
    { _assign( rhs._ptr ); return *this; }

    ~BasicRepPtr()
    { _assign( NULL ); }

    Rep *
    repPtr() const
    { return _ptr; }

  private:
    Rep * _ptr;

    void
    _assign( Rep * new_r )
    {
      // Don't miss this test
      if ( new_r != _ptr )
        {
          Rep::unref( _ptr );
          _ptr = new_r;
          Rep::ref( _ptr );
        }
    }
};



//
//      CLASS NAME : VarPtr
template<typename _Rep>
  class VarPtr : public BasicRepPtr
  {
  public:

    VarPtr()
    : BasicRepPtr()
    {}

    explicit
    VarPtr( _Rep * ptr_r )
    : BasicRepPtr( ptr_r )
    {}

  public:

    _Rep *
    operator->()
    { return ptr(); }

    const _Rep *
    operator->() const
    { return ptr(); }

    _Rep &
    operator*()
    { return *ptr(); }

    const _Rep &
    operator*() const
    { return *ptr(); }

  private:

    _Rep *
    ptr() const
    { return static_cast<_Rep *>( BasicRepPtr::repPtr() ); }
  };


template<typename _Rep>
  inline VarPtr<_Rep>
  makeVarPtr( _Rep * ptr )
  { return VarPtr<_Rep>( ptr ); }


#endif // Rep_h