exception.hxx

#pragma once
 
#include <StormByte/crypto/visibility.h>
#include <StormByte/exception.hxx>
 
namespace StormByte::Crypto {
    class STORMBYTE_CRYPTO_PUBLIC Exception: public StormByte::Exception {
        public:
            inline Exception(const std::string& message):
                StormByte::Exception("Crypto", message) {}
 
            template <typename... Args>
            inline Exception(const std::string& component, std::format_string<Args...> fmt, Args&&... args):
                StormByte::Exception("Crypto::" + component, fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC CompressorException: public Exception {
        public:
            inline CompressorException(const std::string& message): Exception(std::string("Compressor: ") + message) {}
 
            template <typename... Args>
            inline CompressorException(std::format_string<Args...> fmt, Args&&... args):
                Exception("Compressor: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC CrypterException: public Exception {
        public:
            inline CrypterException(const std::string& message): Exception(std::string("Crypter: ") + message) {}
 
            template <typename... Args>
            inline CrypterException(std::format_string<Args...> fmt, Args&&... args):
                Exception("Crypter: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC HasherException: public Exception {
        public:
            inline HasherException(const std::string& message): Exception(std::string("Hasher: ") + message) {}
 
            template <typename... Args>
            inline HasherException(std::format_string<Args...> fmt, Args&&... args):
                Exception("Hasher: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC KeyPairException: public Exception {
        public:
            inline KeyPairException(const std::string& message): Exception(std::string("KeyPair: ") + message) {}
 
            template <typename... Args>
            inline KeyPairException(std::format_string<Args...> fmt, Args&&... args):
                Exception("KeyPair: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC SecretException: public Exception {
        public:
            inline SecretException(const std::string& message): Exception(std::string("Secret: ") + message) {}
 
            template <typename... Args>
            inline SecretException(std::format_string<Args...> fmt, Args&&... args):
                Exception("Secret: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
 
    class STORMBYTE_CRYPTO_PUBLIC SignerException: public Exception {
        public:
            inline SignerException(const std::string& message): Exception(std::string("Signer: ") + message) {}
 
            template <typename... Args>
            inline SignerException(std::format_string<Args...> fmt, Args&&... args):
                Exception("Signer: ", fmt, std::forward<Args>(args)...) {}
 
            // Intentionally do not inherit base constructors to avoid MSVC overload ambiguities
    };
}