exception.h

#ifndef __SEAL_EXCEPTION_H__
#define __SEAL_EXCEPTION_H__

#include <string>
#include <sstream>
#include <iostream>

namespace seal
{

class Exception
{
public:

    Exception() {}

    virtual ~Exception() {}

    virtual std::string getMessage(void) = 0;

}; // Class Exception

// **************************************************************************
// **************************************************************************
// **************************************************************************

class OutOfBoundsException : public Exception
{
public:
    
    OutOfBoundsException(void) : Exception() 
    {
        #ifdef __SEAL_DEBUG__
 
        std::cerr << "EXCEPTION:: You are trying to access memory "
                  << "beyond the bounds of the collection.\n"
                  << "If you dont see any further information, then this"
                  << "message is through an OutOfBoundsException.\n\n";

        #endif // __SEAL_DEBUG__
    }

    virtual ~OutOfBoundsException() {}

    virtual std::string getMessage(void) 
    { 
        return std::string("You are accessing memory beyond the bounds of the collection.\n"); 
    }

}; // Class OutOfBoundsException

// *******************************************************************************
// *******************************************************************************
// *******************************************************************************

template <typename T>
class OutOfRangeException : public OutOfBoundsException
{
public:
    OutOfRangeException(const T &lowerBound, const T &upperBound, const T &requestedValue);

    virtual ~OutOfRangeException() {}

    virtual std::string getMessage(void);

    T getAllowedLowerLimit() { return lowerLimit; }

    T getAllowedUpperLimit() { return upperLimit; }

private:
    OutOfRangeException() {}
    T lowerLimit, upperLimit, value;

}; // Class OutOfRangeException


template <typename T>
OutOfRangeException<T>::OutOfRangeException(const T &allowedLowerLimit, const T &allowedUpperLimit,
                                            const T &requestedValue)
                      : OutOfBoundsException(), 
                        lowerLimit(allowedLowerLimit),
                        upperLimit(allowedUpperLimit),
                        value(requestedValue)
{
    if (lowerLimit > upperLimit)
    {
        lowerLimit = allowedUpperLimit;
        upperLimit = allowedLowerLimit;
    }

    #ifdef __SEAL_DEBUG__
 
    std::cerr << "\nRange information is as follows (Generated from OutOfRangeException):\n"
              << "Allowed Lower Limit  - " << lowerLimit << "\n"
              << "Allowed Upper Limit  - " << upperLimit << "\n"
              << "Requested Value      - " << requestedValue << "\n\n";

    #endif // __SEAL_DEBUG__

}

template <typename T>
std::string OutOfRangeException<T>::getMessage()
{
    std::stringstream ss;

    ss << "Allowed Lower Limit  - " << lowerLimit << "\n"
       << "Allowed Upper Limit  - " << upperLimit << "\n"
       << "Requested Value      - " << value << "\n";

    return ss.str();
}

// **************************************************************************
// **************************************************************************
// **************************************************************************

class EmptyCollectionException : public Exception
{
public:
    EmptyCollectionException(void) : Exception()
    {
        #ifdef __SEAL_DEBUG__
 
        std::cerr << "The collection object whose members you are trying "
                  << "to access in empty.\n";
        #endif // __SEAL_DEBUG__
    }

    ~EmptyCollectionException() {}

    virtual std::string getMessage(void)
    {
        std::stringstream ss;
        ss << "The collection object whose members you are trying to access is empty.\n";

        return ss.str();
    }
}; // EmptyCollectionException

// **************************************************************************
// **************************************************************************
// **************************************************************************

class MissingPriorityException : public Exception
{
public:
    MissingPriorityException(void) : Exception()
    {
        #ifdef __SEAL_DEBUG__
            std::cerr << "ERROR: Trying to access a element with a non-existant priority.\n";
        #endif // __SEAL_DEBUG__
    }

    ~MissingPriorityException() {}

    virtual std::string getMessage(void)
    {
        std::stringstream ss;
        ss << "Trying to access a element with a non-existant priority.\n";

        return ss.str();
    }
}; // EmptyCollectionException

} // End of namespace seal

#endif // __SEAL_EXCEPTION_H__

---