peak_exception.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <stdexcept>
 
 
namespace peak
{
namespace core
{

class Exception : public virtual peak::common::Exception
{
    using peak::common::Exception::Exception;
};

class AbortedException : public Exception
{
    using Exception::Exception;
};

class BadAccessException : public Exception
{
    using Exception::Exception;
};

class BadAllocException
    : public Exception
    , public peak::common::BadAllocException
{
public:
    explicit BadAllocException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::BadAllocException(what)
    {}
 
    explicit BadAllocException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::BadAllocException(what)
    {}
 
    BadAllocException(const BadAllocException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::BadAllocException(other)
    {}
};

class InternalErrorException
    : public Exception
    , public peak::common::InternalErrorException
{
public:
    explicit InternalErrorException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InternalErrorException(what)
    {}
 
    explicit InternalErrorException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InternalErrorException(what)
    {}
 
    InternalErrorException(const InternalErrorException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::InternalErrorException(other)
    {}
};

class InvalidAddressException : public Exception
{
    using Exception::Exception;
};

class InvalidArgumentException
    : public Exception
    , public peak::common::InvalidParameterException
{
public:
    explicit InvalidArgumentException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InvalidParameterException(what)
    {}
 
    explicit InvalidArgumentException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InvalidParameterException(what)
    {}
 
    InvalidArgumentException(const InvalidArgumentException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::InvalidParameterException(other)
    {}
};

class InvalidCastException
    : public Exception
    , public peak::common::InvalidCastException
{
public:
    explicit InvalidCastException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InvalidCastException(what)
    {}
 
    explicit InvalidCastException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::InvalidCastException(what)
    {}
 
    InvalidCastException(const InvalidCastException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::InvalidCastException(other)
    {}
};

class InvalidInstanceException : public Exception
{
    using Exception::Exception;
};

class NotAvailableException : public Exception
{
    using Exception::Exception;
};

class NotFoundException : public Exception
{
    using Exception::Exception;
};

class NotImplementedException : public Exception
{
    using Exception::Exception;
};

class NotInitializedException
    : public Exception
    , public peak::common::LibraryNotInitializedException
{
public:
    explicit NotInitializedException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::LibraryNotInitializedException(what)
    {}
 
    explicit NotInitializedException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::LibraryNotInitializedException(what)
    {}
 
    NotInitializedException(const NotInitializedException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::LibraryNotInitializedException(other)
    {}
};

class OutOfRangeException
    : public Exception
    , public peak::common::OutOfRangeException
{
public:
    explicit OutOfRangeException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::OutOfRangeException(what)
    {}
 
    explicit OutOfRangeException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::OutOfRangeException(what)
    {}
 
    OutOfRangeException(const OutOfRangeException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::OutOfRangeException(other)
    {}
};

class TimeoutException
    : public Exception
    , public peak::common::TimeoutException
{
public:
    explicit TimeoutException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::TimeoutException(what)
    {}
 
    explicit TimeoutException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::TimeoutException(what)
    {}
 
    TimeoutException(const TimeoutException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::TimeoutException(other)
    {}
};

class IOException
    : public Exception
    , public peak::common::IOException
{
public:
    explicit IOException(const std::string& what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::IOException(what)
    {}
 
    explicit IOException(const char* what)
        : peak::common::Exception(what)
        , peak::core::Exception(what)
        , peak::common::IOException(what)
    {}
 
    IOException(const IOException& other)
        : peak::common::Exception(other)
        , peak::core::Exception(other)
        , peak::common::IOException(other)
    {}
};

class NoDataException : public Exception
{
    using Exception::Exception;
};

class CTILoadingException : public Exception
{
    using Exception::Exception;
};
 
} /* namespace core */
} /* namespace peak */