error_handling_intf.h

Go to the documentation of this file.

 
#pragma once
#include <adtfucom3/adtf_ucom3.h>
 
namespace adtf
{
namespace base
{
namespace elasto
{
 
class IErrorHandling: public ucom::ant::IObject
{
    public:
        ADTF_IID(IErrorHandling, "error_handling.elasto.services.adtf.iid");
 
    public:
        enum class tAction: uint32_t
        {
            Ignore = 0, 
            Log, 
            Stop, 
            Shutdown, 
            Abort 
        };
 
        class IErrorHandler: public ucom::ant::IObject
        {
            public:
                ADTF_IID(IErrorHandler, "error_handler.error_handling.elasto.services.adtf.iid");
 
            public:
                virtual void Handle(tResult oError) = 0;
 
            protected:
                ~IErrorHandler() = default;
        };
 
    public:
 
        virtual tResult CreateErrorHandler(const char* strErrorSource,
                                           const char* strErrorCategory,
                                           tAction eDefaultAction,
                                           ucom::ant::iobject_ptr<IErrorHandler>& pHandler) = 0;
 
    protected:
        ~IErrorHandling() = default;
};
 
class cErrorHandler: public ucom::catwo::object<IErrorHandling::IErrorHandler>
{
    public:
        cErrorHandler(const char* strErrorSource,
                      const char* strErrorCategory,
                      IErrorHandling::tAction eAction);
 
        void Handle(tResult oError) override;
 
        IErrorHandling::tAction GetAction() const;
 
        void SetAction(IErrorHandling::tAction eAction);
 
        const char* GetErrorSource() const;
 
        const char* GetErrorCategory() const;
 
    private:
        A_UTILS_D(cErrorHandler)
};
 
ucom::ant::object_ptr<IErrorHandling::IErrorHandler> create_error_handler(const char* strErrorSource,
                                                                          const char* strErrorCategory,
                                                                          IErrorHandling::tAction eDefaultAction);
 
void handle_error(const char* strErrorSource,
                   const char* strErrorCategory,
                   IErrorHandling::tAction eDefaultAction,
                   tResult oError);
 
}
 
namespace flash
{
 
class cErrorChecker
{
    public:
        inline cErrorChecker()
        {}
        inline cErrorChecker(const char* strErrorSource,
                             const char* strErrorCategory,
                             elasto::IErrorHandling::tAction eDefaultAction):
            m_pErrorHandler(elasto::create_error_handler(strErrorSource,
                                                         strErrorCategory,
                                                         eDefaultAction))
        {}
        void Create(const char* strErrorSource,
                    const char* strErrorCategory,
                    elasto::IErrorHandling::tAction eDefaultAction)
        {
            m_pErrorHandler = elasto::create_error_handler(strErrorSource,
                                                           strErrorCategory,
                                                           eDefaultAction);
        }
        inline void Check(tResult oResult)
        {
            if (IS_FAILED(oResult) && m_pErrorHandler)
            {
                m_pErrorHandler->Handle(oResult);
            }
        }
 
    private:
        ucom::ant::object_ptr<elasto::IErrorHandling::IErrorHandler> m_pErrorHandler;
};
 
}
 
using elasto::IErrorHandling;
using elasto::cErrorHandler;
using elasto::create_error_handler;
using elasto::handle_error;
using flash::cErrorChecker;
 
}
}