Exception.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>
#include <list>
#include <stdexcept>

#include "zypp/base/Errno.h"

namespace zypp
{ 

  namespace exception_detail
  { 

    struct CodeLocation
    {
      friend std::ostream & operator<<( std::ostream & str, const CodeLocation & obj );

      CodeLocation()
      : _line( 0 )
      {}

      CodeLocation( const std::string & file_r,
                    const std::string & func_r,
                    unsigned            line_r )
      : _file( file_r ), _func( func_r ), _line( line_r )
      {}

      std::string asString() const;

    private:
      std::string _file;
      std::string _func;
      unsigned    _line;
    };

    //#define ZYPP_EX_CODELOCATION ::zypp::exception_detail::CodeLocation(__FILE__,__FUNCTION__,__LINE__)
#define ZYPP_EX_CODELOCATION ::zypp::exception_detail::CodeLocation(( *__FILE__ == '/' ? strrchr( __FILE__, '/' ) + 1 : __FILE__ ),__FUNCTION__,__LINE__)

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

  } // namespace exception_detail

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

  public:
    typedef exception_detail::CodeLocation CodeLocation;
    typedef std::list<std::string>         History;
    typedef History::const_iterator        HistoryIterator;
    typedef History::size_type             HistorySize;

    Exception();

    Exception( const std::string & msg_r );

    Exception( const std::string & msg_r, const Exception & history_r );

    virtual ~Exception() throw();

    const CodeLocation & where() const
    { return _where; }

    void relocate( const CodeLocation & where_r ) const
    { _where = where_r; }

    const std::string & msg() const
    { return _msg; }

    std::string asString() const;

    std::string asUserString() const;

  public:

    void remember( const Exception & old_r );

    void addHistory( const std::string & msg_r );

    HistoryIterator historyBegin() const
    { return _history.begin(); }

    HistoryIterator historyEnd() const
    { return _history.end(); }

    bool historyEmpty() const
    { return _history.empty(); }

    HistorySize historySize() const
    { return _history.size(); }

    std::string historyAsString() const;

    std::string asUserHistory() const;

  protected:

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

  public:
    static std::string strErrno( int errno_r );
    static std::string strErrno( int errno_r, const std::string & msg_r );

  public:
    static void log( const Exception & excpt_r, const CodeLocation & where_r,
                     const char *const prefix_r );

  private:
    mutable CodeLocation _where;
    std::string          _msg;
    History              _history;

    virtual const char * what() const throw()
    { return _msg.c_str(); }

    std::ostream & dumpError( std::ostream & str ) const;
  };

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


  template<class _Excpt>
    void _ZYPP_THROW( const _Excpt & excpt_r, const exception_detail::CodeLocation & where_r ) __attribute__((noreturn));
  template<class _Excpt>
    void _ZYPP_THROW( const _Excpt & excpt_r, const exception_detail::CodeLocation & where_r )
    {
      excpt_r.relocate( where_r );
      Exception::log( excpt_r, where_r, "THROW:   " );
      throw( excpt_r );
    }

  template<class _Excpt>
    void _ZYPP_CAUGHT( const _Excpt & excpt_r, const exception_detail::CodeLocation & where_r )
    {
      Exception::log( excpt_r, where_r, "CAUGHT:  " );
    }

  template<class _Excpt>
    void _ZYPP_RETHROW( const _Excpt & excpt_r, const exception_detail::CodeLocation & where_r ) __attribute__((noreturn));
  template<class _Excpt>
    void _ZYPP_RETHROW( const _Excpt & excpt_r, const exception_detail::CodeLocation & where_r )
    {
      Exception::log( excpt_r, where_r, "RETHROW: " );
      excpt_r.relocate( where_r );
      throw;
    }


#define ZYPP_THROW(EXCPT)\
  _ZYPP_THROW( EXCPT, ZYPP_EX_CODELOCATION )

#define ZYPP_CAUGHT(EXCPT)\
  _ZYPP_CAUGHT( EXCPT, ZYPP_EX_CODELOCATION )

#define ZYPP_RETHROW(EXCPT)\
  _ZYPP_RETHROW( EXCPT, ZYPP_EX_CODELOCATION )


#define ZYPP_THROW_MSG(EXCPTTYPE, MSG)\
  ZYPP_THROW( EXCPTTYPE( MSG ) )

#define ZYPP_THROW_ERRNO(EXCPTTYPE)\
  ZYPP_THROW( EXCPTTYPE( ::zypp::Exception::strErrno(errno) ) )

#define ZYPP_THROW_ERRNO1(EXCPTTYPE, ERRNO)\
  ZYPP_THROW( EXCPTTYPE( ::zypp::Exception::strErrno(ERRNO) ) )

#define ZYPP_THROW_ERRNO_MSG(EXCPTTYPE, MSG)\
  ZYPP_THROW( EXCPTTYPE( ::zypp::Exception::strErrno(errno,MSG) ) )

#define ZYPP_THROW_ERRNO_MSG1(EXCPTTYPE, ERRNO,MSG)\
  ZYPP_THROW( EXCPTTYPE( ::zypp::Exception::strErrno(ERRNO,MSG) ) )


} // namespace zypp
#endif // ZYPP_BASE_EXCEPTION_H