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-core/base/NonCopyable.h>
#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/base/Function.h>
#include <zypp-core/Pathname.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;
      using dispose_param_type = std::conditional_t< std::is_pointer_v<Tp> || std::is_integral_v<Tp>, Tp const, reference >;
 
    public:
      using Dispose = function<void ( dispose_param_type )>;
 
    public:
      AutoDispose()
      : _pimpl( new Impl( value_type() ) )
      {}
 
      explicit AutoDispose( const Dispose & dispose_r )
      : _pimpl( new Impl( value_type(), dispose_r ) )
      {}
 
      explicit AutoDispose( const value_type & value_r )
      : _pimpl( new Impl( value_r ) )
      {}
 
      AutoDispose( const value_type & value_r, const Dispose & dispose_r )
      : _pimpl( new Impl( value_r, dispose_r ) )
      {}
 
      explicit AutoDispose( value_type &&value_r )
        : _pimpl( new Impl( std::move(value_r) ) )
      {}
 
      AutoDispose( value_type &&value_r, const Dispose & dispose_r )
        : _pimpl( new Impl( std::move(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
      {
        template <typename T>
        Impl( T &&value_r )
          : _value( std::forward<T>(value_r) )
        {}
        template <typename T, typename D>
        Impl( T &&value_r, D &&dispose_r )
          : _value( std::forward<T>(value_r) )
          , _dispose( std::forward<D>(dispose_r) )
        {}
        ~Impl()
        {
          if ( _dispose )
            try { _dispose( _value ); } catch(...) {}
        }
        value_type _value;
        Dispose    _dispose;
      };
 
      shared_ptr<Impl> _pimpl;
    };
 
    template<>
    class AutoDispose<void>
    {
    public:
      typedef function<void ()> Dispose;
 
    public:
      AutoDispose()
        : _pimpl( new Impl() )
      {}
 
      explicit AutoDispose( const Dispose & dispose_r )
        : _pimpl( new Impl( dispose_r ) )
      {}
 
    public:
 
      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( )
        {}
 
        Impl( const Dispose & dispose_r )
          : _dispose( dispose_r )
        {}
 
        ~Impl()
        {
          if ( _dispose )
            try { _dispose(); } catch(...) {}
        }
        Dispose    _dispose;
      };
      shared_ptr<Impl> _pimpl;
    };
 
  using OnScopeExit = AutoDispose<void>;
 
 
  template<class Tp>
    inline std::ostream & operator<<( std::ostream & str, const AutoDispose<Tp> & obj )
    { return str << obj.value(); }
 
 
  struct AutoFD : public AutoDispose<int>
  {
    AutoFD( int fd_r = -1 ) : AutoDispose<int>( fd_r, [] ( int fd_r ) { if ( fd_r != -1 ) ::close( fd_r ); } ) {}
  };
 
  struct AutoFILE : public AutoDispose<FILE*>
  {
    AutoFILE( FILE* file_r = nullptr ) : AutoDispose<FILE*>( file_r, [] ( FILE* file_r ) { if ( file_r ) ::fclose( file_r ); } ) {}
  };
 
  template <typename Tp>
  struct AutoFREE : public AutoDispose<Tp*>
  {
    AutoFREE( Tp* ptr_r = nullptr ) : AutoDispose<Tp*>( ptr_r, [] ( Tp* ptr_r ) { if ( ptr_r ) ::free( ptr_r ); } ) {}
    AutoFREE( void* ptr_r ) : AutoFREE( static_cast<Tp*>(ptr_r) ) {}
  };
 
  template <>
  struct AutoFREE<void> : public AutoDispose<void*>
  {
    AutoFREE( void* ptr_r = nullptr ) : AutoDispose<void*>( ptr_r, [] ( void* ptr_r ) { if ( ptr_r ) ::free( ptr_r ); } ) {}
  };
} // namespace zypp
#endif // ZYPP_AUTODISPOSE_H