multi_clock_exceptions.hpp

Go to the documentation of this file.

#ifndef __MULTI_CLOCK_EXCEPTIONS_HPP
#define __MULTI_CLOCK_EXCEPTIONS_HPP

#include <exception>

namespace zero::multi_clock {

    typedef uint32_t ClockIndex;

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index>
    class MultiHandedClock;

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index = clock_count>
    class MultiHandedClockException : public std::exception {
    public:
        MultiHandedClockException(const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                                                         invalid_clock_index>* multiHandedClock) :
                _multiHandedClock(multiHandedClock) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "An unknown exception happened in the MultiHandedClock instance %p",
                                            _multiHandedClock);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "An unknown exception happened in the MultiHandedClock instance %p",
                     _multiHandedClock);
            return whatSentence;
        };

    protected:
        const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                               invalid_clock_index>* _multiHandedClock;
    };

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index = clock_count>
    class MultiHandedClockEmptyException : public MultiHandedClockException<key_type, value_type, clock_count,
                                                                            invalid_index, invalid_clock_index> {
    public:
        MultiHandedClockEmptyException(const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                                                              invalid_clock_index>* multiHandedClock,
                                       const ClockIndex& emptyClock) :
                MultiHandedClockException<key_type, value_type, clock_count, invalid_index, invalid_clock_index>(
                        multiHandedClock),
                _emptyClock(emptyClock) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The clock %u of MultiHandedClock instance %p was unexpectedly empty.",
                                            _emptyClock, this->_multiHandedClock);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The clock %u of MultiHandedClock instance %p was unexpectedly empty.",
                     _emptyClock, this->_multiHandedClock);
            return whatSentence;
        };

    protected:
        const ClockIndex _emptyClock;
    };

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index = clock_count>
    class MultiHandedClockInvalidIndexException : public MultiHandedClockException<key_type, value_type, clock_count,
                                                                                   invalid_index, invalid_clock_index> {
    public:
        MultiHandedClockInvalidIndexException(const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                                                                     invalid_clock_index>* multiHandedClock,
                                              const key_type& invalidIndex) :
                MultiHandedClockException<key_type, value_type, clock_count, invalid_index, invalid_clock_index>(
                        multiHandedClock),
                _invalidIndex(invalidIndex) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The index %u is invalid for the MultiHandedClock instance %p.",
                                            _invalidIndex, this->_multiHandedClock);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The index %u is invalid for the MultiHandedClock instance %p.",
                     _invalidIndex, this->_multiHandedClock);
            return whatSentence;
        };

    protected:
        const key_type _invalidIndex;
    };

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index = clock_count>
    class MultiHandedClockAlreadyContainedException : public MultiHandedClockException<key_type, value_type,
                                                                                       clock_count, invalid_index,
                                                                                       invalid_clock_index> {
    public:
        MultiHandedClockAlreadyContainedException(
                const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                                       invalid_clock_index>* multiHandedClock,
                const key_type& alreadyContainedIndex) :
                MultiHandedClockException<key_type, value_type, clock_count, invalid_index, invalid_clock_index>(
                        multiHandedClock),
                _alreadyContainedIndex(alreadyContainedIndex) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The index %u is unexpectedly already contained in the MultiHandedClock instance %p.",
                                            _alreadyContainedIndex, this->_multiHandedClock);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The index %u is unexpectedly already contained in the MultiHandedClock instance %p.",
                     _alreadyContainedIndex, this->_multiHandedClock);
            return whatSentence;
        };

    protected:
        const key_type _alreadyContainedIndex;
    };

    template<class key_type,
             class value_type, uint32_t clock_count, key_type invalid_index, key_type invalid_clock_index = clock_count>
    class MultiHandedClockNotContainedException : public MultiHandedClockException<key_type, value_type, clock_count,
                                                                                   invalid_index, invalid_clock_index> {
    public:
        MultiHandedClockNotContainedException(const MultiHandedClock<key_type, value_type, clock_count, invalid_index,
                                                                     invalid_clock_index>* multiHandedClock,
                                              const key_type& notContainedIndex) :
                MultiHandedClockException<key_type, value_type, clock_count, invalid_index, invalid_clock_index>(
                        multiHandedClock),
                _notContainedIndex(notContainedIndex) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The index %u is unexpectedly not contained in the MultiHandedClock instance %p.",
                                            _notContainedIndex, this->_multiHandedClock);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The index %u is unexpectedly not contained in the MultiHandedClock instance %p.",
                     _notContainedIndex, this->_multiHandedClock);
            return whatSentence;
        };

    protected:
        const key_type _notContainedIndex;
    };
}

#endif // __MULTI_CLOCK_EXCEPTIONS_HPP