ge211_error.hxx

#pragma once
 
#include "ge211_forward.hxx"
#include "ge211_noexcept.hxx"
 
#include <exception>
#include <memory>
#include <sstream>
#include <string>
 
namespace ge211 {
 
namespace exceptions {
 
class Exception_base : public std::exception
{
public:
    const char* what() const NOEXCEPT override;
 
private:
    explicit Exception_base(const std::string& message);
 
    friend Client_logic_error;
    friend Environment_error;
 
    std::shared_ptr<const std::string> message_;
};
 
class Client_logic_error : public Exception_base
{
public:
    explicit Client_logic_error(const std::string& message);
};
 
class Session_needed_error : public Client_logic_error
{
public:
    const std::string& attempted_action() const { return action_; }
 
private:
    friend class detail::Session;
 
    explicit Session_needed_error(const std::string& action);
 
    std::string action_;
};
 
class Late_paint_error final : public Client_logic_error
{
    explicit Late_paint_error(char const* who);
 
    // Throwers
    friend ::ge211::internal::Render_sprite;
};
 
class Environment_error : public Exception_base
{
    explicit Environment_error(const std::string& message);
 
    friend Window;
 
    friend Ge211_logic_error;
    friend Host_error;
};
 
class Ge211_logic_error : public Environment_error
{
    explicit Ge211_logic_error(const std::string& message);
 
    friend Mixer;
    friend Text_sprite;
};
 
class Host_error : public Environment_error
{
    explicit Host_error(const std::string& extra_message = "");
 
    friend File_error;
    friend Font_error;
    friend Image_error;
    friend Mixer_error;
 
    friend Text_sprite;
    friend Window;
    friend ::ge211::internal::Render_sprite;
    friend class detail::Renderer;
    friend class detail::Texture;
};
 
class File_error final : public Host_error
{
    explicit File_error(const std::string& message);
    static File_error could_not_open(const std::string& filename);
 
    friend class detail::File_resource;
 
    template <bool>
    friend struct detail::ifstream_opener;
};
 
class Font_error final : public Host_error
{
    explicit Font_error(const std::string& message);
    static Font_error could_not_load(const std::string& filename);
 
    friend Font;
};
 
class Image_error final : public Host_error
{
    explicit Image_error(const std::string& message);
    static Image_error could_not_load(const std::string& filename);
 
    friend Image_sprite;
};
 
class Mixer_error : public Host_error
{
    Mixer_error(const std::string& message);
    static Mixer_error could_not_load(const std::string& filename);
    static Mixer_error out_of_channels();
    static Mixer_error not_enabled();
 
    friend Mixer;
    friend Audio_clip;
    friend Music_track;
    friend Sound_effect;
};
 
} // end namespace exception
 
namespace internal {
 
namespace logging {
 
enum class Log_level
{
    debug,
    info,
    warn,
    fatal,
};
 
class Logger
{
public:
    Log_level level() const NOEXCEPT { return level_; }
 
    void level(Log_level level) NOEXCEPT { level_ = level; }
 
    static Logger& instance() NOEXCEPT;
 
private:
    Logger() NOEXCEPT = default;
 
    Log_level level_ = Log_level::warn;
};
 
class Log_message
{
public:
    explicit Log_message(Log_level level = Log_level::debug);
 
    explicit Log_message(std::string reason,
                         Log_level level = Log_level::debug) NOEXCEPT;
 
    template <typename STREAM_INSERTABLE>
    Log_message& operator<<(STREAM_INSERTABLE const& value)
    {
        if (active_) message_ << value;
        return *this;
    }
 
    virtual ~Log_message();
 
    Log_message(const Log_message&) = delete;
 
    Log_message& operator=(const Log_message&) = delete;
 
    Log_message(Log_message&&) = default;
 
    Log_message& operator=(Log_message&&) = default;
 
private:
    std::string reason_;
    std::ostringstream message_;
    bool active_;
};
 
Log_message debug(std::string reason = "");
 
Log_message info(std::string reason = "");
 
Log_message warn(std::string reason = "");
 
Log_message fatal(std::string reason = "");
 
} // end namespace logging
 
} // end namespace internal
 
namespace detail {
 
using Log_message = internal::logging::Log_message;
 
// These functions generate log messages with the reason set to the
// cause of SDL2's most recent message.
 
Log_message info_sdl();
Log_message warn_sdl();
Log_message fatal_sdl();
 
} // end namespace detail
 
}