exception.hxx

#pragma once
 
#include <StormByte/database/sqlite/type.hxx>
#include <StormByte/exception.hxx>
 
namespace StormByte::Database::SQLite {
    class STORMBYTE_DATABASE_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_DATABASE_PUBLIC WrongResultType: public Exception {
        public:
            WrongResultType(const Type& source_type, const Type& asked_type);
            
            WrongResultType(const WrongResultType&)                 = default;
 
            WrongResultType(WrongResultType&&) noexcept             = default;
 
            WrongResultType& operator=(const WrongResultType&)      = default;
 
            WrongResultType& operator=(WrongResultType&&) noexcept  = default;
 
            ~WrongResultType() noexcept override                    = default;
    };
 
    class STORMBYTE_DATABASE_PUBLIC ConnectionError: public Exception {
        public:
            ConnectionError(const std::string& reason);
 
            ConnectionError(std::string&& reason);
 
            ConnectionError(const ConnectionError&)                 = default;
 
            ConnectionError(ConnectionError&&) noexcept             = default;
 
            ConnectionError& operator=(const ConnectionError&)      = default;
 
            ConnectionError& operator=(ConnectionError&&) noexcept  = default;
 
            ~ConnectionError() noexcept override                    = default;
    };
 
    class STORMBYTE_DATABASE_PUBLIC QueryError: public Exception {
        public:
            QueryError(const std::string& reason);
 
            QueryError(std::string&& reason);
 
            QueryError(const QueryError&)                   = default;
 
            QueryError(QueryError&&) noexcept               = default;
 
            QueryError& operator=(const QueryError&)        = default;
 
            QueryError& operator=(QueryError&&) noexcept    = default;
 
            ~QueryError() noexcept override                 = default;
    };
}