peak_icv_exception.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_icv/utils/peak_icv_defines.hpp>
#include <peak_icv_c/types/peak_icv_simple_types.h>
 
#include <stdexcept>
#include <string>
#include <vector>
 
namespace peak
{
namespace icv
{
 
class Exception : public virtual peak::common::Exception
{
private:
    peak_icv_status m_status;
 
public:
    Exception(const std::string& msg, peak_icv_status status)
        : peak::common::Exception(msg)
        , m_status{ status }
    {}
 
    PEAK_ICV_NO_DISCARD peak_icv_status GetStatus() const;
};
 
class InvalidConfigurationException final : public Exception
{
public:
    explicit InvalidConfigurationException(const std::string& msg, peak_icv_status status)
        : peak::common::Exception(msg)
        , Exception(msg, status)
    {}
 
    InvalidConfigurationException(const InvalidConfigurationException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class InternalErrorException final
    : public Exception
    , public peak::common::InternalErrorException
{
public:
    explicit InternalErrorException(const std::string& msg, peak_icv_status status)
        : peak::common::Exception(msg)
        , Exception(msg, status)
        , peak::common::InternalErrorException(msg)
    {}
 
    InternalErrorException(const InternalErrorException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
        , peak::common::InternalErrorException(other)
    {}
};
 
class MismatchException final : public Exception
{
public:
    explicit MismatchException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_MISMATCH)
    {}
 
    MismatchException(const MismatchException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class NotSupportedException final
    : public Exception
    , public peak::common::NotSupportedException
{
public:
    explicit NotSupportedException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_NOT_SUPPORTED)
        , peak::common::NotSupportedException(msg)
    {}
 
    NotSupportedException(const NotSupportedException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
        , peak::common::NotSupportedException(other)
    {}
};
 
class NotPossibleException final : public Exception
{
public:
    explicit NotPossibleException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_NOT_POSSIBLE)
    {}
 
    NotPossibleException(const NotPossibleException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class OutOfRangeException final
    : public Exception
    , public peak::common::OutOfRangeException
{
public:
    explicit OutOfRangeException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_OUT_OF_RANGE)
        , peak::common::OutOfRangeException(msg)
    {}
 
    OutOfRangeException(const OutOfRangeException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
        , peak::common::OutOfRangeException(other)
    {}
};
 
class MathErrorException final : public Exception
{
public:
    explicit MathErrorException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_MATH_ERROR)
    {}
 
    MathErrorException(const MathErrorException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class TargetNotFoundException final : public Exception
{
public:
    explicit TargetNotFoundException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_TARGET_NOT_FOUND)
    {}
 
    TargetNotFoundException(const TargetNotFoundException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class CorruptedException final : public Exception
{
public:
    explicit CorruptedException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_CORRUPTED)
    {}
 
    CorruptedException(const CorruptedException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
class IOException final
    : public Exception
    , public peak::common::IOException
{
public:
    explicit IOException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_IO_ERROR)
        , peak::common::IOException(msg)
    {}
 
    IOException(const IOException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
        , peak::common::IOException(other)
    {}
};
 
class NullPointerException final : public Exception
{
public:
    explicit NullPointerException(const std::string& msg)
        : peak::common::Exception(msg)
        , Exception(msg, PEAK_ICV_STATUS_NULL_POINTER)
    {}
 
    NullPointerException(const NullPointerException& other) noexcept
        : peak::common::Exception(other)
        , Exception(other)
    {}
};
 
inline peak_icv_status Exception::GetStatus() const
{
    return m_status;
}
 
 
} /* namespace icv */
} /* namespace peak */