exception.h

 
#ifndef _aspose_system_exception_h_
#define _aspose_system_exception_h_
 
#include <system/details/is_forwarding_of.h>
#include <system/object.h>
#include <system/string.h>
#include <system/shared_ptr.h>
#include <system/runtime/serialization/streaming_context.h>
#include <exception>
#include <type_traits>
#include <cstdint>
#include <memory>
 
namespace System
{
namespace Runtime { namespace Serialization {
class SerializationInfo;
}}
 
namespace Collections { namespace Generic {
template<typename, typename>
class IDictionary;
}}
 
class Details_Exception;
 
using ExceptionPtr = System::SmartPtr<Details_Exception>;
 
template<class T>
class ExceptionWrapper;
 
class ExceptionWrapperHelper
{
    template<class T> friend class System::ExceptionWrapper;
 
    template <class T>
    class BaseTypeProvider
    {
    public:
        static typename T::BaseType Dummy;
        using BaseType = decltype(ExceptionWrapperHelper::BaseTypeProvider<T>::Dummy);
    };
};
 
class ASPOSECPP_SHARED_CLASS ExceptionWrapperBase : public ExceptionWrapperType, public std::exception
{
public:
    ASPOSECPP_SHARED_API ExceptionWrapperBase(std::nullptr_t);
 
    ASPOSECPP_SHARED_API ExceptionWrapperBase(const ExceptionPtr& ptr);
 
    virtual ASPOSECPP_SHARED_API const char* what() const noexcept override;
 
    ExceptionPtr Get() const { return m_ptr; }
 
    ASPOSECPP_SHARED_API bool IsNull() const;
 
    ASPOSECPP_SHARED_API bool operator == (const ExceptionWrapperBase &e) const;
 
    ASPOSECPP_SHARED_API bool operator == (const std::nullptr_t) const;
 
    ASPOSECPP_SHARED_API bool operator != (const std::nullptr_t) const;
 
    ASPOSECPP_SHARED_API bool Equals(const ExceptionWrapperBase &e) const;
 
    ASPOSECPP_SHARED_API bool Is(const System::TypeInfo &target) const;
 
    ASPOSECPP_SHARED_API int GetHashCode() const;
 
    ASPOSECPP_SHARED_API String ToString() const;
 
protected:
    ExceptionPtr m_ptr;
};
 
template <typename T>
class ASPOSECPP_SHARED_CLASS ExceptionWrapper  : public ExceptionWrapper<typename ExceptionWrapperHelper::BaseTypeProvider<T>::BaseType> 
{
private:
    using ExceptionBaseType = typename ExceptionWrapperHelper::BaseTypeProvider<T>::BaseType;
 
public:
    operator SharedPtr<Object>()
    {
        return ExceptionWrapper<ExceptionBaseType>::m_ptr.ToObjectPtr();
    }
 
    using ExceptionType = T;
 
    static void* operator new(std::size_t) = delete;
    static void* operator new[](std::size_t) = delete;
 
    static const System::TypeInfo& Type() { return T::Type(); }
 
    ExceptionWrapper(std::nullptr_t) : ExceptionWrapper<ExceptionBaseType>(nullptr) {}
 
    ExceptionWrapper(const ExceptionPtr& ptr) : ExceptionWrapper<T>(static_cast<T*>(ptr.get())) {}
 
    ExceptionWrapper(const ExceptionWrapper& other) : ExceptionWrapper<ExceptionBaseType>(other.m_ptr) {}
 
    ExceptionWrapper(ExceptionWrapper&& other) noexcept
        : ExceptionWrapper<ExceptionBaseType>(std::forward<ExceptionPtr>(other.m_ptr)) {}
 
    ExceptionWrapper& operator=(const ExceptionWrapper& other)
    {
        if (this != &other)
            ExceptionWrapper<ExceptionBaseType>::m_ptr = other.m_ptr;
 
        return *this;
    }
 
    ExceptionWrapper& operator=(ExceptionWrapper&& other) noexcept
    {
        if (this != &other)
            ExceptionWrapper<ExceptionBaseType>::m_ptr = std::move(other.m_ptr);
 
        return *this;
    }
 
    template <typename ...Args,
              typename = std::enable_if_t<
                  !System::Details::IsForwardingOf<ExceptionPtr, Args...>::value &&
                  !System::Details::IsForwardingOf<ExceptionWrapper<T>, Args...>::value>>
    explicit ExceptionWrapper(Args&& ...args)
        : ExceptionWrapper<ExceptionBaseType>(
            static_pointer_cast<Details_Exception>(
                T::MakeObject(
                    std::forward<Args>(args)...
                )
            )
        )
    {}
 
    T* operator->() const
    {
        return static_cast<T*>(ExceptionWrapper<ExceptionBaseType>::m_ptr.GetObjectNotNull());
    }
 
protected:
    ExceptionWrapper(T* ptr) : ExceptionWrapper<ExceptionBaseType>(static_cast<ExceptionBaseType*>(ptr)) {}
};
 
template <typename T>
struct ASPOSECPP_SHARED_CLASS CastResult<ExceptionWrapper<T>>
{
    typedef ExceptionWrapper<T> type;
};
 
template <>
class ASPOSECPP_SHARED_CLASS ExceptionWrapper<Details_Exception> : public ExceptionWrapperBase
{
public:
    ASPOSECPP_SHARED_API operator SharedPtr<Object>();
 
    using ExceptionType = Details_Exception;
 
    static ASPOSECPP_SHARED_API ExceptionWrapper<Details_Exception> NullException;
 
    static void* operator new(std::size_t) = delete;
    static void* operator new[](std::size_t) = delete;
    
    static const ASPOSECPP_SHARED_API System::TypeInfo& Type();
 
    ASPOSECPP_SHARED_API ExceptionWrapper(std::nullptr_t);
 
    ASPOSECPP_SHARED_API ExceptionWrapper();
 
    ASPOSECPP_SHARED_API ExceptionWrapper(const ExceptionPtr& ptr);
 
    ASPOSECPP_SHARED_API ExceptionWrapper(const String& message);
 
    ASPOSECPP_SHARED_API ExceptionWrapper(const String &message, const ExceptionWrapper<Details_Exception>& innerException);
 
    ASPOSECPP_SHARED_API ExceptionWrapper(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context);
 
    ASPOSECPP_SHARED_API Details_Exception* operator->() const;
 
    [[noreturn]] ASPOSECPP_SHARED_API void Throw() const;
 
protected:
    ASPOSECPP_SHARED_API ExceptionWrapper(Details_Exception* ptr);
};
 
class ASPOSECPP_SHARED_CLASS Details_Exception : public System::Object
{
    RTTI_INFO_NAMED(System::Details_Exception, "System::Exception", ::System::BaseTypesInfo<System::Object>);
 
    template <typename T> friend class ExceptionWrapper;
 
public:
    // imitate to C# .Message property for correct translation
    virtual ASPOSECPP_SHARED_API String get_Message() const;
 
    virtual ASPOSECPP_SHARED_API String get_StackTrace() const;
 
    virtual ASPOSECPP_SHARED_API ExceptionWrapper<Details_Exception> get_InnerException() const;
 
    virtual ASPOSECPP_SHARED_API ExceptionWrapper<Details_Exception> GetBaseException() const;
 
    ASPOSECPP_SHARED_API int32_t get_HResult() const;
 
    ASPOSECPP_SHARED_API void set_HResult(int32_t value);
 
    virtual ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IDictionary<SharedPtr<Object>, SharedPtr<Object>>> get_Data();
 
    virtual ASPOSECPP_SHARED_API String ToString() const override;
 
    virtual ASPOSECPP_SHARED_API const char* what() const noexcept;
 
    [[noreturn]] virtual ASPOSECPP_SHARED_API void DoThrow(const ExceptionPtr& self) const;
 
protected:
    ASPOSECPP_SHARED_API Details_Exception();
    MEMBER_FUNCTION_MAKE_OBJECT(Details_Exception, CODEPORTING_ARGS(), CODEPORTING_ARGS());
 
    ASPOSECPP_SHARED_API Details_Exception(const String& message);
    MEMBER_FUNCTION_MAKE_OBJECT(Details_Exception, CODEPORTING_ARGS(const String& message), CODEPORTING_ARGS(message));
 
    ASPOSECPP_SHARED_API Details_Exception(const String &message, const ExceptionWrapper<Details_Exception>& innerException);
    MEMBER_FUNCTION_MAKE_OBJECT(Details_Exception, CODEPORTING_ARGS(const String &message, const ExceptionWrapper<Details_Exception>& innerException), CODEPORTING_ARGS(message, innerException));
 
    ASPOSECPP_SHARED_API Details_Exception(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context);
    MEMBER_FUNCTION_MAKE_OBJECT(Details_Exception,
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context),
        CODEPORTING_ARGS(info, context)
    );
 
    String m_message;
    System::ExceptionWrapper<Details_Exception> m_innerexception;
    SharedPtr<Collections::Generic::IDictionary<SharedPtr<Object>, SharedPtr<Object>>> m_data;
 
    mutable std::string m_std_message;
 
    mutable int32_t m_HResult;
 
    // Use it in derived classes
    virtual ASPOSECPP_SHARED_API String ExtraDescription() const;
 
    String DefaultMessage() const;
 
private:
    virtual ASPOSECPP_SHARED_API String FullMessage(const String& message) const;
 
    Details_Exception(const Details_Exception&) = delete;
    Details_Exception& operator=(const Details_Exception&) = delete;
};
 
using Exception = ExceptionWrapper<Details_Exception>;
 
ASPOSECPP_SHARED_API void PrintTo(const Details_Exception& exception, std::ostream* stream);
 
template <typename T>
void PrintTo(const ExceptionWrapper<T>& exception_wrapper, std::ostream* stream)
{
    T* exception = exception_wrapper.operator->();
    if (exception == nullptr)
        *stream << "nullptr";
    else
        PrintTo(*exception, stream);
}
 
inline std::ostream& operator<<(std::ostream& stream, const Exception& exception)
{
    if (exception != nullptr)
        stream << exception->ToString();
    return stream;
}
 
inline std::wostream& operator<<(std::wostream& stream, const Exception& exception)
{
    if (exception != nullptr)
        stream << exception->ToString();
    return stream;
}
 
} // namespace System
 
ASPOSECPP_SHARED_API bool operator != (const System::ExceptionWrapperBase& e1, const System::ExceptionWrapperBase& e2);
 
ASPOSECPP_SHARED_API bool operator == (std::nullptr_t, const System::ExceptionWrapperBase &e);
 
ASPOSECPP_SHARED_API bool operator != (std::nullptr_t, const System::ExceptionWrapperBase &e);
 
#endif // _aspose_system_exception_h_