exception.hxx

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-System.
 *
 * StormByte-System is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * or later, as published by the Free Software Foundation.
 *
 * StormByte-System is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with StormByte-System. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 */
 
#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;
    };
}