exception.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
#if !defined(KRATOS_EXCEPTION_H_INCLUDED )
#define  KRATOS_EXCEPTION_H_INCLUDED
 
// System includes
#include <stdexcept>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
 
// External includes
 
// Project includes
#include "includes/kratos_export_api.h"
#include "includes/code_location.h"
#include "utilities/stl_vector_io.h"
 
namespace Kratos
{
 
 
class KRATOS_API(KRATOS_CORE) Exception
    : public std::exception
{
public:
 
 
    Exception();
 
    explicit Exception(const std::string& rWhat );
 
    Exception(const std::string& rWhat, const CodeLocation& Location);
 
    Exception(Exception const& Other);
 
    ~Exception() noexcept override;
 
 
 
    Exception& operator=(Exception const& rOther) = delete;
 
    Exception& operator << (CodeLocation const& TheLocation);
 
    template<class StreamValueType>
    Exception& operator << (StreamValueType const& rValue)
    {
        std::stringstream buffer;
        buffer << rValue;
 
        append_message(buffer.str());
 
        return *this;
    }
 
    Exception& operator << (std::ostream& (*pf)(std::ostream&));
    Exception& operator << (const char * rString);
 
 
    void append_message(std::string const& rMessage);
 
    void add_to_call_stack(CodeLocation const& TheLocation);
 
 
 
 
    const char* what() const noexcept override;
 
    const std::string& message() const;
 
    const CodeLocation where() const;
 
 
    virtual std::string Info() const;
 
    virtual void PrintInfo(std::ostream& rOStream) const;
 
    virtual void PrintData(std::ostream& rOStream) const;
 
 
 
private:
 
    std::string mMessage;
    std::string mWhat;
    std::vector<CodeLocation> mCallStack;
 
 
    void update_what();
 
 
}; // Class Exception
 
 
 
#define KRATOS_ERROR throw Kratos::Exception("Error: ", KRATOS_CODE_LOCATION)
#define KRATOS_ERROR_IF(conditional) if(conditional) KRATOS_ERROR
#define KRATOS_ERROR_IF_NOT(conditional) if(!(conditional)) KRATOS_ERROR
 
#ifdef KRATOS_DEBUG
#define KRATOS_DEBUG_ERROR KRATOS_ERROR
#define KRATOS_DEBUG_ERROR_IF(conditional) KRATOS_ERROR_IF(conditional)
#define KRATOS_DEBUG_ERROR_IF_NOT(conditional)  KRATOS_ERROR_IF_NOT(conditional)
#else
#define KRATOS_DEBUG_ERROR if(false) KRATOS_ERROR
#define KRATOS_DEBUG_ERROR_IF(conditional) if(false) KRATOS_ERROR_IF(conditional)
#define KRATOS_DEBUG_ERROR_IF_NOT(conditional) if(false) KRATOS_ERROR_IF_NOT(conditional)
#endif
 
 
std::istream& operator >> (std::istream& rIStream,
                Exception& rThis);
 
KRATOS_API(KRATOS_CORE) std::ostream& operator << (std::ostream& rOStream, const Exception& rThis);
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_EXCEPTION_H_INCLUDED  defined