error.hpp

Go to the documentation of this file.

/*
  ERROR.hpp  -  Lumiera Exception Interface (C++)

  Copyright (C)         Lumiera.org
    2008,2010           Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LUMIERA_ERROR_HPP_
#define LUMIERA_ERROR_HPP_

#define _STDBOOL_H // prevent <atomic> from including stdbool.h

#include "include/logging.h"
#include "lib/hash-standard.hpp"
#include "lib/error.h"

#include <exception>
#include <string>


#define LERR_(_NAME_) lumiera::error::LUMIERA_ERROR_##_NAME_

namespace lumiera {
  
  using std::string;
  using CStr = const char*;
  
  namespace error {
    LUMIERA_ERROR_DECLARE(EXCEPTION);
  }
  
  
  class Error
    : public std::exception
    {
      lumiera_err const id_;  
      string           msg_;  
      string          desc_;  
      mutable string  what_;  
      const string   cause_;  
      
      
    public:
      virtual ~Error ()   noexcept { };  
      
      
      Error (string description=""
                   ,lumiera_err const id =LERR_(EXCEPTION))  noexcept;
      Error (std::exception const& cause
                   ,string description=""
                   ,lumiera_err const id =LERR_(EXCEPTION))  noexcept;
      
      Error (Error &&)                = default;
      Error (Error const&)            = default;
      Error& operator= (Error &&)     = delete;
      Error& operator= (Error const&) = delete;
      
      virtual CStr
      what ()  const noexcept override;
      
      lumiera_err
      getID ()  const noexcept
        {
          return id_;
        }
      
      string const&
      getUsermsg ()  const noexcept
        {
          return msg_;
        }
      
      string const&
      rootCause ()  const noexcept
        {
          return cause_;
        }
      
      Error&
      setUsermsg (string const& newMsg)  noexcept
        {
          msg_ = newMsg;
          return *this;
        }
      
      Error&
      prependInfo (string const& text)  noexcept
        {
          desc_.insert (0, text);
          return *this;
        }
      
      
    private:
      static const string
      extractCauseMsg (std::exception const&)  noexcept;
    };
  
  
  
  
  
  
  /* === Exception sub-categories === */
  
  namespace error {
    
    void lumiera_unexpectedException ()  noexcept;
    
    void assertion_terminate (const string& location);
    
    
    /* constants to be used as error IDs */
    LUMIERA_ERROR_DECLARE (LOGIC    );    
    LUMIERA_ERROR_DECLARE (FATAL    );    
    LUMIERA_ERROR_DECLARE (CONFIG   );    
    LUMIERA_ERROR_DECLARE (STATE    );    
    LUMIERA_ERROR_DECLARE (FLAG     );    
    LUMIERA_ERROR_DECLARE (INVALID  );    
    LUMIERA_ERROR_DECLARE (EXTERNAL );    
    LUMIERA_ERROR_DECLARE (ASSERTION);    
    
    /* generic error situations */
    LUMIERA_ERROR_DECLARE (LIFECYCLE);    
    LUMIERA_ERROR_DECLARE (WRONG_TYPE);   
    LUMIERA_ERROR_DECLARE (ITER_EXHAUST); 
    LUMIERA_ERROR_DECLARE (CAPACITY);     
    LUMIERA_ERROR_DECLARE (SAFETY_LIMIT); 
    LUMIERA_ERROR_DECLARE (INDEX_BOUNDS); 
    LUMIERA_ERROR_DECLARE (BOTTOM_VALUE); 
    LUMIERA_ERROR_DECLARE (UNCONNECTED);  
    LUMIERA_ERROR_DECLARE (UNIMPLEMENTED);
    
    
    
    template<lumiera_err const& eID, class PAR =Error>
    class LumieraError
      : public PAR
      {
      public:
        LumieraError (std::string description=""
                     ,lumiera_err const id=eID)  noexcept
          : PAR{description, id? id:eID}
        { }
        LumieraError (std::exception const& cause
                     ,std::string description=""
                     ,lumiera_err const id=eID)  noexcept
          : PAR{cause, description, id? id:eID}
        { }
      };
    
    //----CLASS-------------------ID--------------PARENT------
    using Logic    = LumieraError<LERR_(LOGIC)>;
    using Fatal    = LumieraError<LERR_(FATAL),   Logic>;
    using State    = LumieraError<LERR_(STATE)>;
    using Flag     = LumieraError<LERR_(FLAG),    State>;
    using Invalid  = LumieraError<LERR_(INVALID)>;
    using Config   = LumieraError<LERR_(CONFIG),  Invalid>;
    using External = LumieraError<LERR_(EXTERNAL)>;
    
    
    void install_unexpectedException_handler();
    
    CStr detailInfo();
    
  } // namespace error
  
  
  
  inline void
  throwOnError()
  {
    if (lumiera_err errorFlag =lumiera_error())
      {
        throw error::Flag( error::detailInfo()
                         , errorFlag);
  }   }
  
  template<class EX>
  inline void
  maybeThrow (string description ="")
  {
    if (lumiera_err errorFlag =lumiera_error())
      {
        throw EX (error::Flag{error::detailInfo(), errorFlag}
                 ,description);
  }   }
  
  
} // namespace lumiera

/**************************************************/
#define ERROR_LOG_AND_IGNORE(_FLAG_,_OP_DESCR_) \
  catch (std::exception& problem)                \
    {                                             \
      const char* errID = lumiera_error();         \
      WARN (_FLAG_, "%s failed: %s", _OP_DESCR_, problem.what()); \
      TRACE (debugging, "Error flag was: %s", errID);\
    }                                                 \
  catch (...)                                          \
    {                                                   \
      const char* errID = lumiera_error();               \
      ERROR (_FLAG_, "%s failed with unknown exception; " \
                     "error flag is: %s"                   \
                   , _OP_DESCR_, errID?errID:"??");         \
    }

#define ERROR_LOG_AND_RETHROW(_FLAG_,_OP_DESCR_) \
  catch (std::exception& problem)                 \
    {                                              \
      const char* errID = lumiera_error();          \
      WARN (_FLAG_, "%s failed: %s", _OP_DESCR_, problem.what()); \
      TRACE (debugging, "Error flag was: %s", errID); \
      throw;                                           \
    }                                                   \
  catch (...)                                            \
    {                                                     \
      const char* errID = lumiera_error();                 \
      ERROR (_FLAG_, "%s failed with unknown exception; "   \
                     "error flag is: %s"                     \
                   , _OP_DESCR_, errID?errID:"??");           \
      throw;                                                   \
    }

/******************************************************/
#define ON_EXCEPTION_RETURN(_VAL_,_OP_DESCR_)   \
  catch (std::exception& problem)                \
    {                                             \
      const char* errID = lumiera_error();         \
      WARN (stage, "%s (Handler) failed: %s",       \
                   _OP_DESCR_, problem.what());      \
      TRACE (debugging, "Error flag was: %s", errID); \
      return (_VAL_);                                  \
    }                                                   \
  catch (...)                                            \
    {                                                     \
      const char* errID = lumiera_error();                 \
      ERROR (stage, "(Handler) %s failed with "             \
                    "unknown exception; error flag is: %s"   \
                   , _OP_DESCR_, errID?errID:"??");           \
      return (_VAL_);                                          \
    }



/**************************************************/
#if 0 
#ifdef NOBUG_ABORT
#undef NOBUG_ABORT
#define LUMIERA_NOBUG_LOCATION \
  std::string (NOBUG_BASENAME(__FILE__)) +":"+ NOBUG_STRINGIZE(__LINE__) + ", function " + __func__
#define NOBUG_ABORT \
  lumiera::error::assertion_terminate (LUMIERA_NOBUG_LOCATION);
#endif
#endif

#endif // LUMIERA_ERROR_HPP_