exceptions.hh

Go to the documentation of this file.

#ifndef EXCEPTIONS_HH
#define EXCEPTIONS_HH
 
#include <exception>
#include <iostream>
 
#include <yaml-cpp/yaml.h>
 
#include "types.hh"
 
 
namespace Utopia {
 
class Exception : public std::runtime_error {
public:
    const int exit_code;
 
 
    explicit Exception(const std::string& what_arg, const int exit_code_arg=1)
    :
        std::runtime_error(what_arg),
        exit_code(exit_code_arg)
    {};
 
 
    explicit Exception(const char* what_arg, const int exit_code_arg=1)
    :
        std::runtime_error(what_arg),
        exit_code(exit_code_arg)
    {};
};
 
 
 
class GotSignal : public Exception {
public:
 
    GotSignal(const int signum)
    :
        Exception("Received signal: " + std::to_string(signum),
                  128 + abs(signum))
    {}
};
 
 
class KeyError : public Exception {
public:
    KeyError(const std::string& key,
             const DataIO::Config& node,
             const std::string& prefix = "")
    :
        Exception(generate_what_arg(key, node, prefix))
    {}
 
private:
    std::string generate_what_arg(std::string key,
                                  DataIO::Config node,
                                  std::string prefix)
    {
        std::stringstream msg;
 
        if (prefix.length()) {
            msg << prefix << std::endl;
        }
 
        msg << "KeyError: " << key << std::endl;
 
        if (not node) {
            msg << "The given node is a Zombie! Make sure the node you are "
                << "trying to read from is valid." << std::endl;
        }
        else if (node.size() == 0) {
            msg << "The given node contains no entries! Make sure the desired "
                << "key is available."
                << std::endl;
        }
        else {
            // Emit the node to give more clues at what might have gone wrong
            msg << "Make sure the desired key is available. The content of "
                << "the given node is as follows:" << std::endl
                << YAML::Dump(node) << std::endl;
        }
 
        return msg.str();
    }
};
 
 
class OutOfSpace : public Exception {
public:
    template<class VecT, class Space>
    OutOfSpace(const VecT& invalid_pos,
               const std::shared_ptr<Space>& space,
               const std::string prefix = {})
    :
        Exception([&](){
            std::stringstream emsg;
            if (prefix.length() > 0) {
                emsg << prefix << " ";
            }
            emsg << "The given position " << std::endl << invalid_pos
                 << "is not within the non-periodic space with extent"
                 << std::endl << space->extent;
            return emsg.str();
        }())
    {}
};
 
 
 
template<class exc_t>
int handle_exception(exc_t& exc) {
    std::cerr << exc.what() << std::endl;
    return exc.exit_code;
}
 
} // namespace Utopia
 
#endif // EXCEPTIONS_HH