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 <utility>
 
#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() = default;
      CodeLocation(const CodeLocation &) = default;
      CodeLocation(CodeLocation &&) = default;
      CodeLocation &operator=(const CodeLocation &) = default;
      CodeLocation &operator=(CodeLocation &&) = default;

      CodeLocation( std::string  file_r,
                    std::string  func_r,
                    unsigned            line_r )
      : _file(std::move( file_r )), _func(std::move( 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 ZYPP_API Exception : public std::exception
  {
    friend std::ostream & operator<<( std::ostream & str, const Exception & obj );
 
  public:
    using CodeLocation = exception_detail::CodeLocation;
    using History = std::list<std::string>;
    using HistoryIterator = History::const_iterator;
    using HistorySize = History::size_type;

    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 );

    ~Exception() throw() override;

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

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

    void relocate( CodeLocation &&where_r ) const
    { _where = std::move(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, 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;

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

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


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

  std::ostream & operator<<( std::ostream & str, const std::exception_ptr &excptPtr ) ZYPP_API;

  namespace exception_detail
  {
    template<class TExcpt>
    using EnableIfIsException = std::enable_if_t< std::is_base_of_v<Exception,TExcpt>, int>;

    template<class TExcpt>
    using EnableIfNotException = std::enable_if_t< !std::is_base_of_v<Exception,TExcpt>, int>;
 

    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, EnableIfIsException<TExcpt> = 0>
    void do_ZYPP_THROW( const TExcpt & excpt_r, CodeLocation && where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfIsException<TExcpt>>
    void do_ZYPP_THROW( const TExcpt & excpt_r, CodeLocation && where_r )
    {
      Exception::log( excpt_r, where_r, "THROW:   " );
      excpt_r.relocate(std::move(where_r) );
      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:  " );
    }

    void do_ZYPP_CAUGHT ( const std::exception_ptr & excpt_r, CodeLocation &&where_r );
 

    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, EnableIfIsException<TExcpt> = 0>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, CodeLocation && where_r ) __attribute__((noreturn));
    template<class TExcpt, EnableIfIsException<TExcpt>>
    void do_ZYPP_RETHROW( const TExcpt & excpt_r, CodeLocation && where_r )
    {
      Exception::log( excpt_r, where_r, "RETHROW: " );
      excpt_r.relocate( std::move(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;
    }
 
    void do_ZYPP_RETHROW( const std::exception_ptr & excpt_r, const CodeLocation & where_r );

    template<class TExcpt>
    std::exception_ptr do_ZYPP_EXCPT_PTR( TExcpt && excpt_r, CodeLocation && where_r )
    {
      if constexpr( std::is_base_of_v<Exception, std::decay_t<TExcpt>> ) {
        Exception::log( excpt_r, where_r, "THROW (EXCPTR):   " );
        excpt_r.relocate( std::move(where_r) );
      } else {
        Exception::log( typeid(excpt_r).name(), where_r, "THROW (EXCPTR):   " );
      }
      return std::make_exception_ptr<std::decay_t<TExcpt>>( std::forward<TExcpt>(excpt_r) );
    }

    std::exception_ptr do_ZYPP_FWD_EXCPT_PTR( const std::exception_ptr & excpt_r, CodeLocation &&where_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_FWD_EXCPT(EXCPT)\
  ::zypp::exception_detail::do_ZYPP_FWD_EXCPT_PTR( EXCPT, ZYPP_EX_CODELOCATION )

#define ZYPP_FWD_CURRENT_EXCPT()\
  ::zypp::exception_detail::do_ZYPP_FWD_EXCPT_PTR( std::current_exception(), 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