exceptions.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_EXCEPTIONS_H
#define ELEMENTA_BASE_EXCEPTIONS_H
 
#include <exception>
#include <string>
#include <sstream>
#include <iomanip>
#include "elementa/base/debugging.h"
 
namespace elementa
{
 
namespace base
{
 
/* ****************************************************************************
 
    Macro: ELE_CODE_EXCOVERRIDE
    Class: Exc
 
******************************************************************************/
 
 
#define ELE_CLASS_EXCOVERRIDE(C) C & asERR(const std::string & contxt) noexcept\
                                                                     override \
                                    { elementa::base::Exc::asERR(contxt); \
                                      return(*this); } \
                             C & asEXC(const std::string & place, \
                                       const elementa::base::RTTextWithEnum::\
                                                Combination & fl =\
                                         {elementa::base::RTTextWith::kAll_}) \
                                            noexcept override\
                                    { elementa::base::Exc::asEXC(place,fl); \
                                      return(*this); }
 
 
 
 
class Exc: public std::runtime_error
{
 public:
 
    using StdBase = std::runtime_error;
 
    Exc(const std::string & expl):StdBase{expl},iserr_{false} {}
    
    Exc(const Exc &) = default;
    Exc(Exc &&) = default;
    Exc & operator=(const Exc &) = default;
    Exc & operator=(Exc &&) = default;
    
    virtual ~Exc(void) = default;
    
    virtual Exc & asERR(const std::string & context) noexcept;
    
 
    virtual Exc & asEXC(const std::string & place, 
                        const RTTextWithEnum::Combination & flags = 
                                    {RTTextWith::kAll_}) noexcept;
    
 
    const char * what(void) const noexcept override { return(msg_.c_str()); }
    
    const char * explanation(void) const noexcept { return(StdBase::what()); }
    
    const char * context(void) const noexcept { return(context_.c_str()); }
    
 protected:
 
    std::string msg_; 
 
 private:
 
    bool iserr_;
    std::string context_;
};
 
 
 
/* ****************************************************************************
 
    Classes: unimplemented, todo, notreach, notfound, 
             invalid_state, internal_error
 
******************************************************************************/
 
 
class unimplemented: public Exc
{
 public:
 
    unimplemented(const std::string & explanation): Exc{explanation} {}
    
    ELE_CLASS_EXCOVERRIDE(unimplemented)
};
 
 
class todo: public Exc
{
 public:
 
    todo(const std::string & explanation): Exc{"TODO: " + explanation} {}
    
    ELE_CLASS_EXCOVERRIDE(todo);
};
 
class notreach: public Exc
{
 public:
 
    notreach(const std::string & explanation): Exc{explanation} {}
    
    ELE_CLASS_EXCOVERRIDE(notreach)
};
 
class invstate: public Exc
{
 public:
 
    invstate(const std::string & expl): Exc{expl} {}
    
    ELE_CLASS_EXCOVERRIDE(invstate)
};
 
class internal_error: public Exc
{
 public:
 
    internal_error(const std::string & expl): Exc{expl} {}
    
    ELE_CLASS_EXCOVERRIDE(internal_error)
};
 
class notfound: public Exc
{
 public:
 
    notfound(const std::string & expl): Exc{expl} {}
    
    ELE_CLASS_EXCOVERRIDE(notfound)
};
 
class invarg: public Exc
{
 public:
 
    invarg(const std::string & expl): Exc{expl} {}
    
    ELE_CLASS_EXCOVERRIDE(invarg)
};
 
class outofrange: public Exc
{
 public:
 
    outofrange(const std::string & expl): Exc{expl} {}
    
    ELE_CLASS_EXCOVERRIDE(outofrange)
};
 
 
 
/* ****************************************************************************
 
    Macros: ELE_CODE_UNIMPLEMENTED, ELE_CODE_TODO, ELE_CODE_NOTREACH,
            ELE_CODE_INVARG, ELE_CODE_INTERNALERR, ELE_CODE_INVSTATE,
            ELE_CODE_OUTOFRANGE
 
******************************************************************************/
 
#define ELE_CODE_UNIMPLEMENTED throw(elementa::base::unimplemented{\
                                        "Unimplemented"}.asEXC(ELE_CODE_PLACE))
 
#define ELE_CODE_TODO(expl) throw(elementa::base::todo{expl}.asEXC(\
                                  ELE_CODE_PLACE))
 
#define ELE_CODE_NOTREACH throw(elementa::base::notreach{\
                                        "Should not reach this point"}.asEXC(\
                                            ELE_CODE_PLACE))
 
#define ELE_CODE_INTERNALERR(expl) throw(elementa::base::internal_error{expl}.\
                                            asEXC(ELE_CODE_PLACE))
 
#define ELE_CODE_INVSTATE(expl) throw(elementa::base::invstate{expl}.\
                                            asEXC(ELE_CODE_PLACE))
 
#define ELE_CODE_INVARG(expl) throw(elementa::base::invarg{expl}.\
                                            asEXC(ELE_CODE_PLACE))
 
#define ELE_CODE_OUTOFRANGE(expl) throw(elementa::base::outofrange{expl}.\
                                            asEXC(ELE_CODE_PLACE))
 
#define ELE_CODE_NOTFOUND(expl) throw(elementa::base::notfound{expl}.\
                                            asEXC(ELE_CODE_PLACE))
 
 
 // Exceptions
 
} // end namespace base
 
} // end namespace elementa
 
#endif