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 <typeinfo>
#include <type_traits>
 
#include <zypp-core/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( std::string && msg_r );
 
    Exception( const std::string & msg_r, const Exception & history_r );
    Exception( std::string && msg_r, const Exception & history_r );
    Exception( const std::string & msg_r, Exception && history_r );
    Exception( std::string && msg_r, 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 remember( Exception && old_r );
 
    void remember( std::exception_ptr old_r );
 
    void remember( const std::string & msg_r )
    { addHistory( msg_r ); }
    void remember( std::string && msg_r )
    { addHistory( std::move(msg_r) ); }
 
    void addHistory( const std::string & msg_r );
    void addHistory( std::string && msg_r );
 
    template<class TContainer>
    void addToHistory( const TContainer & msgc_r )
    {
      for ( const std::string & el : msgc_r )
        addHistory( el );
    }
    template<class TContainer>
    void moveToHistory( TContainer && msgc_r )
    {
      for ( std::string & el : msgc_r )
        addHistory( std::move(el) );
    }
 
    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 );
    static std::string strErrno( int errno_r, std::string && msg_r );
 
  public:
    static void log( const Exception & excpt_r, const CodeLocation & where_r,
                     const char *const prefix_r );
    static void log( const char * typename_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 );
 
  namespace exception_detail
  {
    template<class TExcpt>
    using EnableIfIsException = typename std::enable_if< std::is_base_of<Exception,TExcpt>::value, int>::type;
 
    template<class TExcpt>
    using EnableIfNotException = typename std::enable_if< !std::is_base_of<Exception,TExcpt>::value, int>::type;
 
 
    template<class TExcpt, EnableIfIsException<TExcpt> = 0>
    void do_ZYPP_THROW( const TExcpt & excpt_r, const CodeLocation & where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfIsException<TExcpt>>
    void do_ZYPP_THROW( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      excpt_r.relocate( where_r );
      Exception::log( excpt_r, where_r, "THROW:   " );
      throw( excpt_r );
    }
 
    template<class TExcpt, EnableIfNotException<TExcpt> = 0>
    void do_ZYPP_THROW( const TExcpt & excpt_r, const CodeLocation & where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfNotException<TExcpt>>
    void do_ZYPP_THROW( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( typeid(excpt_r).name(), where_r, "THROW:   " );
      throw( excpt_r );
    }
 
 
    template<class TExcpt, EnableIfIsException<TExcpt> = 0>
    void do_ZYPP_CAUGHT( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( excpt_r, where_r, "CAUGHT:  " );
    }
 
    template<class TExcpt, EnableIfNotException<TExcpt> = 0>
    void do_ZYPP_CAUGHT( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( typeid(excpt_r).name(), where_r, "CAUGHT:  " );
    }
 
 
    template<class TExcpt, EnableIfIsException<TExcpt> = 0>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, const CodeLocation & where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfIsException<TExcpt>>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( excpt_r, where_r, "RETHROW: " );
      excpt_r.relocate( where_r );
      throw;
    }
 
    template<class TExcpt, EnableIfNotException<TExcpt> = 0>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, const CodeLocation & where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfNotException<TExcpt>>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( excpt_r, where_r, "RETHROW: " );
      throw;
    }
 
    template<class TExcpt, EnableIfIsException<TExcpt> = 0>
    std::exception_ptr do_ZYPP_EXCPT_PTR( const TExcpt & excpt_r, const CodeLocation & where_r );
    template<class TExcpt, EnableIfIsException<TExcpt>>
    std::exception_ptr do_ZYPP_EXCPT_PTR( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      excpt_r.relocate( where_r );
      Exception::log( excpt_r, where_r, "EXCPTR:   " );
      return std::make_exception_ptr( excpt_r );
    }
 
    template<class TExcpt, EnableIfNotException<TExcpt> = 0>
    std::exception_ptr do_ZYPP_EXCPT_PTR( const TExcpt & excpt_r, const CodeLocation & where_r );
    template<class TExcpt, EnableIfNotException<TExcpt>>
    std::exception_ptr do_ZYPP_EXCPT_PTR( const TExcpt & excpt_r, const CodeLocation & where_r )
    {
      Exception::log( typeid(excpt_r).name(), where_r, "EXCPTR:   " );
      return std::make_exception_ptr( excpt_r );
    }
 
 
  } // namespace exception_detail
 
#define ZYPP_THROW(EXCPT)\
  ::zypp::exception_detail::do_ZYPP_THROW( EXCPT, ZYPP_EX_CODELOCATION )
 
#define ZYPP_EXCPT_PTR(EXCPT)\
  ::zypp::exception_detail::do_ZYPP_EXCPT_PTR( EXCPT, ZYPP_EX_CODELOCATION )
 
#define ZYPP_CAUGHT(EXCPT)\
  ::zypp::exception_detail::do_ZYPP_CAUGHT( EXCPT, ZYPP_EX_CODELOCATION )
 
#define ZYPP_RETHROW(EXCPT)\
  ::zypp::exception_detail::do_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