exceptions.hpp

#pragma once

#include <ciso646>
#include <string>
#include <exception>

namespace simo
{
namespace shapes
{
namespace exceptions
{

class shapes_exception : public std::exception
{
  public:
    explicit shapes_exception(const char* reason)
        : m_reason(reason) {}

    const char* what() const noexcept override
    {
        return m_reason.c_str();
    }

  protected:
    void set_reason(const std::string& reason)
    {
        m_reason.append(": ");
        m_reason.append(reason);
    }

  private:
    std::string m_reason{};
};

class parse_error : public shapes_exception
{
  public:
    explicit parse_error(const std::string& reason)
        : shapes_exception("parse error")
    {
        set_reason(reason);
    }
};

class not_implemented_error : public shapes_exception
{
  public:
    not_implemented_error()
        : shapes_exception("not implemented error")
    {
    }

    explicit not_implemented_error(const std::string& reason)
        : shapes_exception("not implemented error")
    {
        set_reason(reason);
    }
};

class geometry_error : public shapes_exception
{
  public:
    explicit geometry_error(const std::string& reason)
        : shapes_exception("geometry error")
    {
        set_reason(reason);
    }
};

class index_error : public shapes_exception
{
  public:
    explicit index_error(const std::string& reason)
        : shapes_exception("index error")
    {
        set_reason(reason);
    }
};

}  // namespace exceptions
}  // namespace shapes
}  // namespace simo