hashtable_deque_exceptions.hpp

Go to the documentation of this file.

#ifndef __HASHTABLE_DEQUE_EXCEPTIONS_HPP
#define __HASHTABLE_DEQUE_EXCEPTIONS_HPP

namespace zero::hashtable_deque {

    template<class key_type, key_type invalid_key>
    class HashtableDequeException : public std::exception {
    public:
        HashtableDequeException(const uint64_t& size, const key_type& back, const key_type& front) :
                _size(size),
                _back(back),
                _front(front) {};

        const char* what() const noexcept override {
            return "An unknown exception happened in an instance of HashtableDeque.";
        };

        virtual const char* details() const noexcept {
            int whatStringLength = snprintf(nullptr, 0,
                                            "HashtableDeque.size() = %zd, HashtableDeque._back = %zd, HashtableDeque._front = %zd",
                                            _size, _back, _front);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "HashtableDeque.size() = %zd, HashtableDeque._back = %zd, HashtableDeque._front = %zd",
                     _size, _back, _front);
            return whatSentence;
        };

    protected:
        const uint64_t _size;

        const key_type _back;

        const key_type _front;
    };

    template<class key_type, key_type invalid_key>
    class HashtableDequeAlreadyContainsException : public HashtableDequeException<key_type, invalid_key> {
    public:
        HashtableDequeAlreadyContainsException(const uint64_t& size, const key_type& back, const key_type& front,
                                               const key_type& containedKey) :
                HashtableDequeException<key_type, invalid_key>(size, back, front),
                _containedKey(containedKey) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "%zd was tried to be inserted into an HashtableDeque, but it was already contained in there.",
                                            _containedKey);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "%zd was tried to be inserted into an HashtableDeque, but it was already contained in there.",
                     _containedKey);
            return whatSentence;
        };

    protected:
        const key_type _containedKey;
    };

    template<class key_type, key_type invalid_key>
    class HashtableDequeEmptyException : public HashtableDequeException<key_type, invalid_key> {
    public:
        using HashtableDequeException<key_type, invalid_key>::HashtableDequeException;

        const char* what() const noexcept override {
            return "An HashtableDeque was already empty.";
        };
    };

    template<class key_type, key_type invalid_key>
    class HashtableDequeNotContainedException : public HashtableDequeException<key_type, invalid_key> {
    public:
        HashtableDequeNotContainedException(const uint64_t& size, const key_type& back, const key_type& front,
                                            const key_type& requestedKey) :
                HashtableDequeException<key_type, invalid_key>(size, back, front),
                _requestedKey(requestedKey) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0, "An HashtableDeque does not contain key %zd", _requestedKey);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength, "An HashtableDeque does not contain key %zd", _requestedKey);
            return whatSentence;
        };

    private:
        const key_type _requestedKey;
    };

    template<class key_type, key_type invalid_key>
    class HashtableDequeAlreadyAtTheFrontException : public HashtableDequeException<key_type, invalid_key> {
    public:
        HashtableDequeAlreadyAtTheFrontException(const uint64_t& size, const key_type& back, const key_type& front,
                                                 const key_type& frontKey) :
                HashtableDequeException<key_type, invalid_key>(size, back, front),
                _frontKey(frontKey) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0, "An HashtableDeque has key %zd at the front", _frontKey);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength, "An HashtableDeque has key %zd at the front", _frontKey);
            return whatSentence;
        };

    private:
        const key_type _frontKey;
    };

    template<class key_type, key_type invalid_key>
    class HashtableDequeAlreadyAtTheBackException : public HashtableDequeException<key_type, invalid_key> {
    public:
        HashtableDequeAlreadyAtTheBackException(const uint64_t& size, const key_type& back, const key_type& front,
                                                 const key_type& backKey) :
                HashtableDequeException<key_type, invalid_key>(size, back, front),
                _backKey(backKey) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0, "An HashtableDeque has key %zd at the back", _backKey);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength, "An HashtableDeque has key %zd at the back", _backKey);
            return whatSentence;
        };

    private:
        const key_type _backKey;
    };

}

#endif //__HASHTABLE_DEQUE_EXCEPTIONS_HPP