AAX_Exception.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *  Copyright 2016-2017, 2023-2024 Avid Technology, Inc.
 *  All rights reserved.
 *  
 *  This file is part of the Avid AAX SDK.
 *  
 *  The AAX SDK is subject to commercial or open-source licensing.
 *  
 *  By using the AAX SDK, you agree to the terms of both the Avid AAX SDK License
 *  Agreement and Avid Privacy Policy.
 *  
 *  AAX SDK License: https://developer.avid.com/aax
 *  Privacy Policy: https://www.avid.com/legal/privacy-policy-statement
 *  
 *  Or: You may also use this code under the terms of the GPL v3 (see
 *  www.gnu.org/licenses).
 *  
 *  THE AAX SDK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
 *  EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
 *  DISCLAIMED.
 */
 
/*================================================================================================*/
 
 
#ifndef AAXLibrary_AAX_Exception_h
#define AAXLibrary_AAX_Exception_h
 
#include "AAX_Assert.h"
#include "AAX_StringUtilities.h"
#include "AAX.h"
 
#include <exception>
#include <string>
#include <set>
 
 
#if 0
#pragma mark -
#pragma mark AAX::Exception
#endif
 
namespace AAX
{
    namespace Exception {
        class Any;
    }
    
    inline std::string AsString(const char* inStr);
    inline const std::string& AsString(const std::string& inStr); 
    inline const std::string& AsString(const Exception::Any& inStr); 
    
    
    namespace Exception
    {
        class Any
        {
        public:
            virtual ~Any() {}
            
            template <class C>
            explicit Any(const C& inWhat)
            : mDesc(AAX::AsString(inWhat))
            , mFunction()
            , mLine()
            , mWhat(AAX::Exception::Any::CreateWhat(mDesc, mFunction, mLine))
            {
            }
            
            template <class C1, class C2, class C3>
            explicit Any(const C1& inWhat, const C2& inFunction, const C3& inLine)
            : mDesc(AAX::AsString(inWhat))
            , mFunction(AAX::AsString(inFunction))
            , mLine(AAX::AsString(inLine))
            , mWhat(AAX::Exception::Any::CreateWhat(mDesc, mFunction, mLine))
            {
            }
 
            // copy constructor
            Any(const Any& inOther)
            : mDesc(inOther.mDesc)
            , mFunction(inOther.mFunction)
            , mLine(inOther.mLine)
            , mWhat(inOther.mWhat)
            {
            }
            
            // assignment operator
            Any& operator=(const Any& inOther)
            {
                mDesc = inOther.mDesc;
                mFunction = inOther.mFunction;
                mLine = inOther.mLine;
                mWhat = inOther.mWhat;
                return *this;
            }
            
            AAX_DEFAULT_MOVE_CTOR(Any);
            AAX_DEFAULT_MOVE_OPER(Any);
            
        public: // AAX::Exception::Any
            
#ifndef AAX_CPP11_SUPPORT
            // implicit conversion to std::string (mostly for AsString())
            operator const std::string&(void) const { return mWhat; }
#endif
            
            const std::string& What() const { return mWhat; }
            const std::string& Desc() const { return mDesc; }
            const std::string& Function() const { return mFunction; }
            const std::string& Line() const { return mLine; }
            
        private:
            static std::string CreateWhat(const std::string& inDesc, const std::string& inFunc, const std::string& inLine)
            {
                std::string whatStr(inDesc);
                if (false == inFunc.empty()) { whatStr += (" func:" + inFunc); }
                if (false == inLine.empty()) { whatStr += (" line:" + inLine); }
                return whatStr;
            }
            
        private:
            std::string mDesc;
            std::string mFunction;
            std::string mLine;
            std::string mWhat;
        };
        
        class ResultError : public Any
        {
        public:
            explicit ResultError(AAX_Result inWhatResult)
            : Any(ResultError::FormatResult(inWhatResult))
            , mResult(inWhatResult)
            {
            }
            
            template <class C>
            explicit ResultError(AAX_Result inWhatResult, const C& inFunction)
            : Any(ResultError::FormatResult(inWhatResult), inFunction, (const char*)NULL)
            , mResult(inWhatResult)
            {
            }
            
            template <class C1, class C2>
            explicit ResultError(AAX_Result inWhatResult, const C1& inFunction, const C2& inLine)
            : Any(ResultError::FormatResult(inWhatResult), inFunction, inLine)
            , mResult(inWhatResult)
            {
            }
 
            // copy constructor
            ResultError(const ResultError& inOther)
            : Any(inOther)
            , mResult(inOther.mResult)
            {
            }
            
            static std::string FormatResult(AAX_Result inResult)
            {
                return std::string(AAX::AsStringResult(inResult) + " (" + AAX::AsStringInt32((int32_t)inResult) + ")");
            }
            
            AAX_Result Result() const { return mResult; }
            
        private:
            AAX_Result mResult;
        };
    }
 
    std::string AsString(const char* inStr)
    {
        return inStr ? std::string(inStr) : std::string();
    }
 
    const std::string& AsString(const std::string& inStr)
    {
        return inStr;
    }
 
    const std::string& AsString(const Exception::Any& inStr)
    {
        return inStr.What();
    }
}
 
 
#if 0
#pragma mark -
#endif
 
class AAX_CheckedResult
{
public:
    typedef AAX::Exception::ResultError Exception;
    
    /* non-virtual destructor */ ~AAX_CheckedResult() {}
    
    AAX_CheckedResult()
    : mCurResult(AAX_SUCCESS)
    , mLastError(AAX_SUCCESS)
    , mAcceptedResults()
    {
        Initialize();
    }
    
    AAX_CheckedResult(AAX_Result inResult)
    : mCurResult(inResult)
    , mLastError(AAX_SUCCESS)
    , mAcceptedResults()
    {
        Initialize();
        Check();
    }
    
    void AddAcceptedResult(AAX_Result inResult)
    {
        mAcceptedResults.insert(inResult);
    }
    
    void ResetAcceptedResults()
    {
        mAcceptedResults.clear();
        mAcceptedResults.insert(AAX_SUCCESS);
    }
    
    AAX_CheckedResult& operator=(AAX_Result inResult)
    {
        mCurResult = inResult;
        Check();
        return *this;
    }
    
    AAX_CheckedResult& operator|=(AAX_Result inResult)
    {
        return this->operator=(inResult);
    }
    
    operator AAX_Result() const
    {
        return mCurResult;
    }
    
    void Clear()
    {
        mCurResult = AAX_SUCCESS;
        mLastError = AAX_SUCCESS;
    }
    
    AAX_Result LastError() const
    {
        return mLastError;
    }
    
private:
    void Initialize()
    {
        ResetAcceptedResults();
    }
    
    void Check()
    {
        const AAX_Result err = mCurResult;
        if (0 == mAcceptedResults.count(err))
        {
            AAX_CheckedResult::Exception ex(err);
            
            // error state is now captured in ex
            mCurResult = AAX_SUCCESS;
            mLastError = err;
            
            AAX_TRACE_RELEASE(kAAX_Trace_Priority_Normal, "AAX_CheckedResult - throwing %s", ex.What().c_str());
            AAX_STACKTRACE(kAAX_Trace_Priority_Lowest, ""); // stacktrace is only printed for debug plug-in builds
            throw ex;
        }
    }
    
private:
    AAX_Result mCurResult;
    AAX_Result mLastError;
    std::set<AAX_Result> mAcceptedResults;
};
 
 
#if 0
#pragma mark -
#pragma mark AAX exception macros
#endif
 
#define AAX_SWALLOW(...) \
  try { if(true) { ( __VA_ARGS__ ); } } \
  catch (const AAX_CheckedResult::Exception& AAX_PREPROCESSOR_CONCAT(ex,__LINE__)) { \
    AAX_TRACE_RELEASE(kAAX_Trace_Priority_High, "%s line %d (%s) exception caught: %s (swallowed)", __FILE__, __LINE__, __FUNCTION__, AAX_PREPROCESSOR_CONCAT(ex,__LINE__).What().c_str()); \
  } do {} while (false)
 
#define AAX_SWALLOW_MULT(...) \
try { if(true) { __VA_ARGS__ } } \
catch (const AAX_CheckedResult::Exception& AAX_PREPROCESSOR_CONCAT(ex,__LINE__)) { \
AAX_TRACE_RELEASE(kAAX_Trace_Priority_High, "%s line %d (%s) exception caught: %s (swallowed)", __FILE__, __LINE__, __FUNCTION__, AAX_PREPROCESSOR_CONCAT(ex,__LINE__).What().c_str()); \
} do {} while (false)
 
#define AAX_CAPTURE(X, ...) \
try { if(true) { ( __VA_ARGS__ ); } } \
catch (const AAX::Exception::ResultError& AAX_PREPROCESSOR_CONCAT(ex,__LINE__)) { \
AAX_TRACE_RELEASE(kAAX_Trace_Priority_High, "%s line %d (%s) exception caught: %s (captured)", __FILE__, __LINE__, __FUNCTION__, AAX_PREPROCESSOR_CONCAT(ex,__LINE__).What().c_str()); \
(X) = AAX_PREPROCESSOR_CONCAT(ex,__LINE__).Result(); \
} do {} while (false)
 
#define AAX_CAPTURE_MULT(X, ...) \
try { if(true) { __VA_ARGS__ } } \
catch (const AAX_CheckedResult::Exception& AAX_PREPROCESSOR_CONCAT(ex,__LINE__)) { \
AAX_TRACE_RELEASE(kAAX_Trace_Priority_High, "%s line %d (%s) exception caught: %s (captured)", __FILE__, __LINE__, __FUNCTION__, AAX_PREPROCESSOR_CONCAT(ex,__LINE__).What().c_str()); \
(X) = AAX_PREPROCESSOR_CONCAT(ex,__LINE__).Result(); \
} do {} while (false)
 
 
#if 0
#pragma mark -
#endif
 
class AAX_AggregateResult
{
public:
    AAX_AggregateResult() = default;
    
    ~AAX_AggregateResult()
    {
        if (0 == mNumSucceeded && 0 < mNumFailed) {
            try {
                // do normal logging
                this->Check();
            }
            catch(...)
            {
                // can't throw from a destructor
            }
        }
    }
    
    AAX_AggregateResult& operator=(AAX_Result inResult)
    {
        if (AAX_SUCCESS == inResult)
        {
            ++mNumSucceeded;
        }
        else
        {
            mLastFailure = inResult;
            ++mNumFailed;
        }
        
        return *this;
    }
 
    operator AAX_Result()
    {
        AAX_Result const err = this->LastFailure();
        this->Clear();
        return err;
    }
    
    void Check() const { AAX_CheckedResult tempErr(mLastFailure); }
    void Clear() {
        mLastFailure = AAX_SUCCESS;
        mNumFailed = 0;
        mNumSucceeded = 0;
    }
 
    AAX_Result LastFailure() const { return mLastFailure; }
    int NumFailed() const { return mNumFailed; }
    int NumSucceeded() const { return mNumSucceeded; }
    int NumAttempted() const { return mNumFailed+mNumSucceeded; }
    
private:
    AAX_Result mLastFailure{AAX_SUCCESS};
    int mNumFailed{0};
    int mNumSucceeded{0};
};
 
#endif