AIErrorHandler.h File Reference

#include "AITypes.h"
#include "AIAssert.hpp"

Go to the source code of this file.

Classes
class	AIErrorThrower
	A helper class to handle AIErr when code is designed to handle exceptions. More...
class	AIErrorHandler
	A helper class to handle AIErr. More...
Namespaces
namespace	ai
	Usage:.
Defines
#define	AI_CATCH_RETURN
#define	AI_CATCH_FUNCTION(fn)
#define	AI_CATCH_ASSERT_FUNCTION(fn)
#define	AI_CATCH_ASSERT_RETURN_FUNCTION(fn)
#define	AI_CATCH_ASSERT_RETURN
#define	AI_CATCH_ASSERT_THROW
#define	AI_CATCH_ASSERT_RETURN_ERROR(error)
#define	AI_CATCH_RETURN_ERROR(error)
#define	AI_CATCH_NO_RETURN
#define	AI_CATCH_ASSERT_NO_RETURN
Variables
const AIErr	ai::kUnknownExceptionErr = 'UNEX'
	()
const AIErr	ai::kStdExceptionErr = 'STEX'
	()

---

Define Documentation

#define AI_CATCH_ASSERT_FUNCTION

(

fn

)

Value:

catch (const ai::Error& e) \
        { \
                AIMsgAssert((AIErr)e == kNoErr || (AIErr)e == kCanceledErr, e.what()); \
                fn(e); \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
                fn(ai::kStdExceptionErr); \
        } \
        catch (AIErr e) \
        { \
                AIMsgAssert(e == kNoErr || e == kCanceledErr, ai::kAIErrExceptionStr.c_str()); \
                fn(e); \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
                fn(ai::kUnknownExceptionErr); \
        }

#define AI_CATCH_ASSERT_NO_RETURN

Value:

catch (const ai::Error& e) \
        { \
                AIMsgAssert((AIErr)e == kNoErr || (AIErr)e == kCanceledErr, e.what()); \
                ai::NOTUSED(e); \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
        } \
        catch (AIErr e) \
        { \
                AIMsgAssert(e == kNoErr || e == kCanceledErr, ai::kAIErrExceptionStr.c_str());\
                ai::NOTUSED(e); \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
        }

#define AI_CATCH_ASSERT_RETURN

Value:

catch (const ai::Error& e) \
        { \
                AIMsgAssert((AIErr)e == kNoErr || (AIErr)e == kCanceledErr, e.what()); \
                return (AIErr)e; \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
                return ai::kStdExceptionErr; \
        } \
        catch (AIErr e) \
        { \
                AIMsgAssert(e == kNoErr || e == kCanceledErr, ai::kAIErrExceptionStr.c_str()); \
                return e; \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
                return ai::kUnknownExceptionErr; \
        }

#define AI_CATCH_ASSERT_RETURN_ERROR

(

error

)

Value:

catch (const ai::Error& e) \
        { \
                bool isCovered = (AIErr)e == kNoErr || (AIErr)e == kCanceledErr; \
                AIMsgAssert(isCovered, e.what()); \
                if (!isCovered) \
                return error; \
                return e; \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
                return error; \
        } \
        catch (AIErr e) \
        { \
                bool isCovered = e == kNoErr || e == kCanceledErr; \
                AIMsgAssert(isCovered, ai::kAIErrExceptionStr.c_str()); \
                if (!isCovered) \
                        return error; \
                return e; \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
                return error; \
        }

#define AI_CATCH_ASSERT_RETURN_FUNCTION

(

fn

)

Value:

catch (const ai::Error& e) \
        { \
                AIMsgAssert((AIErr)e == kNoErr || (AIErr)e == kCanceledErr, e.what()); \
                return fn(e); \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
                return fn(ai::kStdExceptionErr); \
        } \
        catch (AIErr e) \
        { \
                AIMsgAssert(e == kNoErr || e == kCanceledErr, ai::kAIErrExceptionStr.c_str()); \
                return fn(e); \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
                return fn(ai::kUnknownExceptionErr); \
        }

#define AI_CATCH_ASSERT_THROW

Value:

catch (const ai::Error& e) \
        { \
                AIMsgAssert((AIErr)e == kNoErr || (AIErr)e == kCanceledErr, e.what()); \
                ai::NOTUSED(e); \
                throw; \
        } \
        catch (const std::exception& e) \
        { \
                AIMsgAssert(false, e.what()); \
                ai::NOTUSED(e); \
                throw; \
        } \
        catch (AIErr e) \
        { \
                AIMsgAssert(e == kNoErr || e == kCanceledErr, ai::kAIErrExceptionStr.c_str()); \
                ai::NOTUSED(e); \
                throw; \
        } \
        catch (...) \
        { \
                AIMsgAssert(false, ai::kUnknownExceptionStr.c_str()); \
                throw; \
        }

#define AI_CATCH_FUNCTION

(

fn

)

Value:

catch (const ai::Error& e) \
        { \
                fn(e); \
        } \
        catch (const std::exception& e) \
        { \
                ai::NOTUSED(e); \
                fn(ai::kStdExceptionErr); \
        } \
        catch (AIErr e) \
        { \
                fn(e); \
        } \
        catch (...) \
        { \
                fn(ai::kUnknownExceptionErr); \
        }

#define AI_CATCH_NO_RETURN

Value:

catch (const ai::Error& ) \
    { \
    } \
    catch (const std::exception& ) \
    { \
    } \
    catch (AIErr) \
    { \
    } \
    catch (...) \
    { \
    }

Referenced by ASUserInteractionChecker::logError(), and ASUserInteractionChecker::logWarning().

#define AI_CATCH_RETURN

Value:

catch (const ai::Error& e) { return (AIErr)e; } \
        catch (const std::exception&) { return ai::kStdExceptionErr; } \
        catch (AIErr e) { return e; } \
        catch (...) { return ai::kUnknownExceptionErr; }

Referenced by ASUserInteractionChecker::logInfo().

#define AI_CATCH_RETURN_ERROR

(

error

)

Value:

catch (const ai::Error& e) \
        { \
                if ((AIErr)e != kNoErr && (AIErr)e != kCanceledErr) \
                        return error; \
                return e; \
        } \
        catch (const std::exception&) \
        { \
                return error; \
        } \
        catch (AIErr e) \
        { \
                if (e != kNoErr && e != kCanceledErr) \
                        return error; \
                return e; \
        } \
        catch (...) \
        { \
                return error; \
        }