Exception.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/Exception.hpp"
 
#else
 
#include "Arp/System/Core/Arp.h"
#include <memory>
#include <iostream>
 
namespace Arp
{
 
class Exception
{
public: // typedefs
    typedef std::shared_ptr<Exception>  Ptr;
 
public: // construction/destruction (policies)
    template<typename... Args>
    Exception(const char* message, const Args& ... args);
    Exception(const String& message);
    Exception(String&& message);
    Exception(const String& message, const Exception& innerException);
    Exception(String&& message, Exception&& innerException);
    Exception(const Exception& arg) = default;
    Exception(Exception&& arg) = default;
    virtual ~Exception(void) = default;
 
protected: //construction
    Exception(String&& message, const Exception::Ptr& innerExceptionPtr);
 
public: // setter/getter properties
    uint32          GetTypeCode(void)const;
    const String&   GetMessage(void)const;
    bool            HasInnerException(void)const;
    Exception::Ptr  GetInnerException(void)const;
 
public: // operations
    String          ToString(void)const;
 
protected: // operations to override
    virtual Exception::Ptr  Clone(void)const;
    virtual String          Format(int indentLevel, bool withInnerException)const;
    virtual uint32          GetTypeCodeInternal(void)const;
 
private: // deleted methods
    Exception& operator=(const Exception& arg) = delete;
 
private: // fields
    String          message;
    Exception::Ptr  innerExceptionPtr;
 
protected: // static fields
    const static int indentSize = 3;        
    const static int indentChar = ' ';      
    const static int innerIndentChar = '-'; 
};
 
// inline methods of class Exception
template<typename... Args>
inline Exception::Exception(const char* messageArg, const Args& ... args)
    : message(String::Format(messageArg, args...))
{
}
 
inline Exception::Exception(const String& messageArg)
    : message(messageArg)
{
}
 
inline Exception::Exception(String&& messageArg)
    : message(std::move(messageArg))
{
}
 
inline Exception::Exception(const String& messageArg, const Exception& innerException)
    : message(messageArg), innerExceptionPtr(innerException.Clone())
{
}
 
inline Exception::Exception(String&& messageArg, Exception&& innerException)
    : message(std::move(messageArg)), innerExceptionPtr(innerException.Clone())
{
}
 
inline Exception::Exception(String&& messageArg, const Exception::Ptr& innerException)
    : message(std::move(messageArg)), innerExceptionPtr(innerException)
{
}
 
inline const String& Exception::GetMessage()const
{
    return this->message;
}
 
inline bool Exception::HasInnerException()const
{
    return (bool)this->innerExceptionPtr;
}
 
inline Exception::Ptr Exception::GetInnerException()const
{
    return this->innerExceptionPtr;
}
 
inline uint32 Exception::GetTypeCode()const
{
    return this->GetTypeCodeInternal();
}
 
// global operators of class Exception
 
inline std::ostream& operator<<(std::ostream& os, const Exception& e)
{
    os << e.ToString();
    return os;
}
 
} // end of namesapce Arp
 
// template specialization of Exception formatter
template<> struct fmt::formatter<Arp::Exception> : public fmt::ostream_formatter {};
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE