Exceptions.hpp

Go to the documentation of this file.

//
// Copyright © 2017-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
 
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace armnn
{
 
struct CheckLocation
{
    const char* m_Function;
    const char* m_File;
    unsigned int m_Line;
 
    CheckLocation(const char* func,
                  const char* file,
                  unsigned int line)
    : m_Function{func}
    , m_File{file}
    , m_Line{line}
    {
    }
 
    std::string AsString() const
    {
        std::stringstream ss;
        ss << " at function " << m_Function
           << " [" << m_File << ':' << m_Line << "]";
        return ss.str();
    }
 
    std::string FileLine() const
    {
        std::stringstream ss;
        ss << " [" << m_File << ':' << m_Line << "]";
        return ss.str();
    }
};
 
/// Base class for all ArmNN exceptions so that users can filter to just those.
class Exception : public std::exception
{
public:
    explicit Exception(const std::string& message);
 
    /// exception with context
    explicit Exception(const std::string& message,
                       const CheckLocation& location);
 
    /// preserving previous exception context
    /// and adding local context information
    explicit Exception(const Exception& other,
                       const std::string& message,
                       const CheckLocation& location);
 
    virtual const char* what() const noexcept override;
 
private:
    std::string m_Message;
};
 
/// Class for non-fatal exceptions raised while initialising a backend
class BackendUnavailableException : public Exception
{
public:
    using Exception::Exception;
};
 
class ClRuntimeUnavailableException : public BackendUnavailableException
{
public:
    using BackendUnavailableException::BackendUnavailableException;
};
 
class InvalidArgumentException : public Exception
{
public:
    using Exception::Exception;
};
 
class FileNotFoundException : public Exception
{
public:
    using Exception::Exception;
};
 
class ParseException : public Exception
{
public:
    using Exception::Exception;
};
 
class UnimplementedException : public Exception
{
public:
    using Exception::Exception;
    UnimplementedException();
};
 
class LayerValidationException : public Exception
{
    using Exception::Exception;
};
 
class GraphValidationException : public Exception
{
    using Exception::Exception;
};
 
class BadOptionalAccessException : public Exception
{
    using Exception::Exception;
};
 
class RuntimeException : public Exception
{
    using Exception::Exception;
};
 
class MemoryImportException : public Exception
{
    using Exception::Exception;
};
 
class MemoryExportException : public Exception
{
    using Exception::Exception;
};
 
class TimeoutException : public Exception
{
    using Exception::Exception;
};
 
class PolymorphicDowncastException : public Exception
{
public:
    using Exception::Exception;
};
 
class NullPointerException : public Exception
{
public:
    using Exception::Exception;
};
 
class BackendCapabilityException : public Exception
{
public:
    using Exception::Exception;
};
 
class MemoryValidationException : public Exception
{
public:
    using Exception::Exception;
};
 
template <typename ExceptionType>
void ConditionalThrow(bool condition, const std::string& message)
{
    if (!condition)
    {
        throw ExceptionType(message);
    }
}
 
template <typename ExceptionType>
void ConditionalThrow(bool condition)
{
    if (!condition)
    {
        throw ExceptionType();
    }
}
 
 
///
/// ComparedType must support:
///   operator==(const ComparedType&)
///   operator<<(ostream&, const ComparedType&)
///
template <typename ExceptionType, typename ComparedType>
void ConditionalThrowIfNotEqual(const std::string& message,
                                const ComparedType& leftHandSide,
                                const ComparedType& rightHandSide)
{
    if (!(leftHandSide == rightHandSide))
    {
        std::stringstream ss;
        ss << message << " : " << leftHandSide << " != " << rightHandSide;
        throw ExceptionType(ss.str());
    }
}
 
} // namespace armnn
 
#define CHECK_LOCATION() armnn::CheckLocation(__func__, __FILE__, __LINE__)
 
// Use to throw rather than assert
#define ARMNN_THROW_MSG_IF_FALSE(_cond, _except, _str) \
    do { if (!(static_cast<bool>(_cond))) {throw _except(_str);} } while(0)
#define ARMNN_THROW_IF_FALSE(_cond, _except) \
    ARMNN_THROW_MSG_IF_FALSE(_cond, _except, #_cond)
#define ARMNN_THROW_INVALIDARG_MSG_IF_FALSE(_cond, _str) \
    ARMNN_THROW_MSG_IF_FALSE(_cond, armnn::InvalidArgumentException, _str)
#define ARMNN_THROW_INVALIDARG_IF_FALSE(_cond) \
    ARMNN_THROW_MSG_IF_FALSE(_cond, armnn::InvalidArgumentException, #_cond)