AutoDispose.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <boost/call_traits.hpp>

#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/base/Function.h"

namespace zypp
{ 

  //
  //    CLASS NAME : AutoDispose<_Tp>
  //
  template<class _Tp>
    class AutoDispose
    {
    public:
      typedef typename boost::call_traits<_Tp>::param_type       param_type;
      typedef typename boost::call_traits<_Tp>::reference        reference;
      typedef typename boost::call_traits<_Tp>::const_reference  const_reference;
      typedef _Tp                                                value_type;
      typedef typename boost::call_traits<_Tp>::value_type       result_type;

    public:
      typedef function<void ( param_type )> Dispose;

    public:
      AutoDispose()
      : _pimpl( new Impl( value_type() ) )
      {}

      explicit AutoDispose( const Dispose & dispose_r )
      : _pimpl( new Impl( value_type(), dispose_r ) )
      {}

      explicit AutoDispose( param_type value_r )
      : _pimpl( new Impl( value_r ) )
      {}

      AutoDispose( param_type value_r, const Dispose & dispose_r )
      : _pimpl( new Impl( value_r, dispose_r ) )
      {}

    public:

      operator reference() const
      { return _pimpl->_value; }

      reference value() const
      { return _pimpl->_value; }

      reference operator*() const
      { return _pimpl->_value; }

      value_type * operator->() const
      { return & _pimpl->_value; }

      void reset()
      { AutoDispose().swap( *this ); }

      void swap( AutoDispose & rhs )
      { _pimpl.swap( rhs._pimpl ); }

    public:
      const Dispose & getDispose() const
      { return _pimpl->_dispose; }

      void setDispose( const Dispose & dispose_r )
      { _pimpl->_dispose = dispose_r; }

      void resetDispose()
      { setDispose( Dispose() ); }

      void swapDispose( Dispose & dispose_r )
      { _pimpl->_dispose.swap( dispose_r ); }

    private:
      struct Impl : private base::NonCopyable
      {
        Impl( param_type value_r )
        : _value( value_r )
        {}
        Impl( param_type value_r, const Dispose & dispose_r )
        : _value( value_r )
        , _dispose( dispose_r )
        {}
        ~Impl()
        {
          if ( _dispose )
            try { _dispose( _value ); } catch(...) {}
        }
        value_type _value;
        Dispose    _dispose;
      };

      shared_ptr<Impl> _pimpl;
    };

  template<class _Tp>
    inline std::ostream & operator<<( std::ostream & str, const AutoDispose<_Tp> & obj )
    { return str << obj.value(); }

} // namespace zypp
#endif // ZYPP_AUTODISPOSE_H