exception.hxx

#pragma once
 
#include <StormByte/exception.hxx>
#include <StormByte/database/visibility.h>
 
namespace StormByte::Database {
    class STORMBYTE_DATABASE_PUBLIC Exception: public StormByte::Exception {
        public:
            Exception(const std::string& reason);
 
            Exception(std::string&& reason);
 
            Exception(const Exception&)                 = default;
 
            Exception(Exception&&) noexcept             = default;
 
            Exception& operator=(const Exception&)      = default;
 
            Exception& operator=(Exception&&) noexcept  = default;
 
            virtual ~Exception() noexcept               = default;
    };
 
    class STORMBYTE_DATABASE_PUBLIC WrongValueType final: public Exception {
        public:
            WrongValueType(const std::string& targettype);
 
            WrongValueType(const WrongValueType&)               = default;
 
            WrongValueType(WrongValueType&&)                    = default;
 
            WrongValueType& operator=(const WrongValueType&)    = default;
 
            WrongValueType& operator=(WrongValueType&&)         = default;
 
            ~WrongValueType() noexcept override                 = default;
    };
 
    class STORMBYTE_DATABASE_PUBLIC ColumnNotFound: public Exception {
        public:
            ColumnNotFound(const std::string& name);
 
            ColumnNotFound(const ColumnNotFound&)                   = default;
 
            ColumnNotFound(ColumnNotFound&&) noexcept               = default;
 
            ColumnNotFound& operator=(const ColumnNotFound&)        = default;
 
            ColumnNotFound& operator=(ColumnNotFound&&) noexcept    = default;
 
            ~ColumnNotFound() noexcept override                     = default;
    };
 
    class STORMBYTE_DATABASE_PUBLIC OutOfBounds: public Exception {
        public:
            OutOfBounds(const size_t& index);
 
            OutOfBounds(const OutOfBounds&)                         = default;
 
            OutOfBounds(OutOfBounds&&) noexcept                     = default;
 
            OutOfBounds& operator=(const OutOfBounds&)              = default;
 
            OutOfBounds& operator=(OutOfBounds&&) noexcept          = default;
 
            ~OutOfBounds() noexcept override                        = default;
    };
}