_Handle.h

Go to the documentation of this file.

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

  File:       _Handle.h

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

  Purpose: Handle/Body: Base for Handle classes manipuating a Body

/-*/
#ifndef _Handle_h
#define _Handle_h

#include <iosfwd>

#include <y2util/_Body.h>

//
//      CLASS NAME : _Handle
class _Handle {

  private:

    _Body * _body;

    static void * operator new( size_t );

  public:

    _Handle() : _body( 0 ) {}
    _Handle( _Body * body_r ) : _body( body_r ) {
      _Body::ref( _body );
    }
    _Handle( const _Handle & rhs ) : _body( rhs._body ) {
      _Body::ref( _body );
    }
    _Handle & operator=( _Body * rhs ) {
      if ( rhs != _body ) {
        _Body::unref( _body );
        _body = rhs;
        _Body::ref( _body );
      }
      return *this;
    }
    _Handle & operator=( const _Handle & rhs ) {
      return operator=( rhs._body );
    }
    virtual ~_Handle() {
      _Body::unref( _body );
    }

  public:

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

    _Body * operator->() { return _body; }

    const _Body * operator->() const { return _body; }

    _Body & operator*() { if ( !_body ) throw( this ); return *_body; }

    const _Body & operator*() const { if ( !_body ) throw( this ); return *_body; }

  public:

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

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


//
//      CLASS NAME : _DHandle<_Tp>
template<typename _Tp> struct _DHandle : public _Handle {

  _DHandle() : _Handle() {}

  _DHandle( _Body * body_r ) : _Handle( body_r ) {}

  _Tp * operator->() {
    return static_cast<_Tp *>(_Handle::operator->());
  }

  const _Tp * operator->() const {
    return static_cast<const _Tp *>(_Handle::operator->());
  }

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

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


#endif // _Handle_h

---