exception.hxx

#pragma once
 
#include <StormByte/exception.hxx>
#include <StormByte/system/visibility.h>
 
#include <filesystem>
 
namespace StormByte::System {
    class STORMBYTE_SYSTEM_PUBLIC Exception: public StormByte::Exception {
        public:
            Exception(const std::string& message);
 
            Exception(const Exception&)                 = default;
 
            Exception(Exception&&) noexcept             = default;
 
            Exception& operator=(const Exception&)      = default;
 
            Exception& operator=(Exception&&) noexcept  = default;
 
            virtual ~Exception() noexcept override      = default;
    };
 
    class STORMBYTE_SYSTEM_PUBLIC FileIOError final: public Exception {
        public:
            enum class Operation { Read = 0, Write }; 
 
            constexpr static const char* operation_to_string(const Operation& op) noexcept {
                switch(op) {
                    case Operation::Read:   return "read";
                    case Operation::Write:  return "write";
                    default:                return "unknown";
                }
            }
 
            FileIOError(const std::filesystem::path& file, const Operation& operation);
 
            FileIOError(const FileIOError&)             = default;
 
            FileIOError(FileIOError&&) noexcept         = default;
 
            FileIOError& operator=(const FileIOError&)  = default;
 
            FileIOError& operator=(FileIOError&&)       = default;
 
            ~FileIOError() noexcept override            = default;
    };
 
    class STORMBYTE_SYSTEM_PUBLIC ExecutableNotFound: public Exception {
        public:
            ExecutableNotFound(const std::filesystem::path& exec);
 
            ExecutableNotFound(const ExecutableNotFound&)                   = default;
 
            ExecutableNotFound(ExecutableNotFound&&) noexcept               = default;
 
            ExecutableNotFound& operator=(const ExecutableNotFound&)        = default;
 
            ExecutableNotFound& operator=(ExecutableNotFound&&) noexcept    = default;
 
            ~ExecutableNotFound() noexcept override                         = default;
    };
}