exceptions.h

 
#pragma once
 
#include <string>
#include <memory>
#include "system/string.h"
#include "system/exception.h"
#include "system/nullable.h"
 
#ifndef E_FAIL__
#define E_FAIL__ 0x80004005
#endif
 
 
//EXCEPTION_NAMESPACE(Parent::Name::Space, Class) or EXCEPTION_NAMESPACE(, System) if there is no parent
#define EXCEPTION_NAMESPACE(pns, ns) namespace ns\
{\
 \
    inline const System::String& CURRENT_NAMESPACE()\
    {\
        static const System::String name = System::String(ASPOSE_T(#pns)).IsEmpty() ? System::String(ASPOSE_T(#ns)) : System::String(ASPOSE_T(#pns) "::" ASPOSE_T(#ns));\
        return name;\
    }\
 \
}\
namespace ns
 
//Reflection helpers similar ones from reflection.h
#define __ThisTypeInfo_Runtime_NameSpace(thisType) \
        struct ThisTypeInfo : System::TypeInfoPtr { \
            ThisTypeInfo() : System::TypeInfoPtr(thisType) {
 
// baseTypes: System::BaseTypesInfo<TypeA, TypeB, TypeC>
#define RTTI_INFO_NAMESPACE(thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Runtime_NameSpace((CURRENT_NAMESPACE() + u"::" + ASPOSE_T(#thisType))) \
    RTTI_INFO_END()
 
//Exception related macros
#define DECLARE_INHERITED_EXCEPTION(name, parent) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent() {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(message) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException) : parent(message, innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG(name, parent) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(DefaultMessageIfNull(message)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) : parent(DefaultMessageIfNull(message), innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG2(name, parent) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(DefaultMessageIfNull(message)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) \
        : parent(DefaultMessageIfNull(message), innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
};
 
#define DECLARE_INHERITED_EXCEPTION_WITH_EXTRA_CODE(name, parent, code) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    int get_##code() { return m_##code; } \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent() {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(int code) : parent(u""), m_##code(code) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(int code), CODEPORTING_ARGS(code)); \
 \
 \
    Details_##name(const System::String &message) : parent(message) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(int code, const System::String &message) : parent(message), m_##code(code) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(int code, const System::String &message), CODEPORTING_ARGS(code, message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) : parent(message, innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), CODEPORTING_ARGS(message, innerException)); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return String::FromUtf8(std::to_string(m_##code)); } \
 \
    int m_##code = E_FAIL__; \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER(name, parent, member) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    String get_##member() { return m_##member; } \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(DefaultMessageIfNull(message)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) : parent(DefaultMessageIfNull(message), innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::String &message, const System::String & member) : parent(DefaultMessageIfNull(message)), m_##member(member) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message, const System::String & member), CODEPORTING_ARGS(message, member)); \
 \
 \
 \
 \
    Details_##name(const System::String &message, const System::String & member, const System::Exception& innerException) \
        : parent(DefaultMessageIfNull(message), innerException), m_##member(member) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::String & member, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, member, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return m_##member; } \
 \
    String m_##member; \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER2(name, parent, member) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    String get_##member() { return m_##member; } \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &member) : parent(MessageDefault()), m_##member(member) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &member), CODEPORTING_ARGS(member)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) : parent(DefaultMessageIfNull(message), innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::String &member, const System::String &message) : parent(DefaultMessageIfNull(message)), m_##member(member) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &member, const System::String &message), CODEPORTING_ARGS(member, message)); \
 \
 \
 \
    template<typename T> Details_##name(const System::String& member, const T&, const System::String& message) : parent(DefaultMessageIfNull(message)), m_##member(member) {} \
    template<typename T> MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String& member, const T& t, const System::String& message), CODEPORTING_ARGS(member, t, message)); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return m_##member; } \
 \
    String m_##member; \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_NON_NULL_MEMBER(name, parent, member) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    String get_##member() { return m_##member; } \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()), m_##member(System::String::Empty) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &member) : parent(MessageDefault()), m_##member(EmptyStringIfNull(member)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &member), CODEPORTING_ARGS(member)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::Exception& innerException) \
        : parent(DefaultMessageIfNull(message), innerException), m_##member(System::String::Empty) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::Exception& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::String &member, const System::String &message) : parent(DefaultMessageIfNull(message)), m_##member(EmptyStringIfNull(member)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &member, const System::String &message), \
        CODEPORTING_ARGS(member, message) \
    ); \
 \
 \
 \
    template<typename T> Details_##name(const System::String& member, const T&, const System::String& message) : parent(DefaultMessageIfNull(message)), m_##member(EmptyStringIfNull(member)) {} \
    template<typename T> MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String& member, const T& t, const System::String& message), CODEPORTING_ARGS(member, t, message)); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return m_##member; } \
 \
    String m_##member; \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& EmptyStringIfNull(const String& member); \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG_AND_SUBSTITUTE_NON_NULL_MEMBER(name, parent, member) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    String get_##member() { return m_##member; } \
protected: \
 \
    using BaseType = parent; \
 \
 \
 \
    Details_##name(const System::String &member, const System::Exception& innerException) \
        : parent(DefaultMessage(member), innerException), m_##member(EmptyStringIfNull(member)) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::String &member, const System::Exception& innerException), \
        CODEPORTING_ARGS(member, innerException) \
    ); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, \
        CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), \
        CODEPORTING_ARGS(info, context) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return m_##member; } \
 \
    String m_##member; \
private: \
 \
 \
 \
    ASPOSECPP_SHARED_API static String DefaultMessage(const String& parameter); \
 \
 \
 \
 \
    ASPOSECPP_SHARED_API static String DefaultMessageIfNull(const String& message, const String& parameter); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& EmptyStringIfNull(const String& member); \
};
 
#define DECLARE_EXTERNAL_EXCEPTION(name, parent, code) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
public: \
 \
 \
    int get_##code() { return m_##code; } \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent() {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(message) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, int code) : parent(message), m_##code(code) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message, int code), CODEPORTING_ARGS(message, code)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException) : parent(message, innerException) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException), CODEPORTING_ARGS(message, innerException)); \
 \
 \
 \
    Details_##name(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : parent(info, context) {} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context), CODEPORTING_ARGS(info, context)); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
 \
 \
    virtual String ExtraDescription() const override { return String::FromUtf8(std::to_string(m_##code)); } \
 \
    int m_##code = E_FAIL__; \
};
 
#define DECLARE_INHERITED_EXCEPTION_MSG_AND_HRESULT(name, parent, hresult) \
class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class ASPOSECPP_SHARED_CLASS Details_##name : public parent { \
    friend class System::ExceptionWrapperHelper; \
    template <typename T> friend class System::ExceptionWrapper; \
    RTTI_INFO_NAMESPACE(name, System::BaseTypesInfo<parent>) \
protected: \
 \
    using BaseType = parent; \
 \
    Details_##name() : parent(MessageDefault()) {m_HResult = hresult;} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(), CODEPORTING_ARGS()); \
 \
 \
    Details_##name(const System::String &message) : parent(DefaultMessageIfNull(message)) {m_HResult = hresult;} \
    MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(const System::String &message), CODEPORTING_ARGS(message)); \
 \
 \
 \
    Details_##name(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException) \
        : parent(DefaultMessageIfNull(message), innerException) {m_HResult = hresult;} \
    MEMBER_FUNCTION_MAKE_OBJECT( Details_##name, \
        CODEPORTING_ARGS(const System::String &message, const System::ExceptionWrapper<System::Details_Exception>& innerException), \
        CODEPORTING_ARGS(message, innerException) \
    ); \
 \
    [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_##name>(self); } \
private: \
 \
 \
    ASPOSECPP_SHARED_API static const String& MessageDefault(); \
 \
 \
 \
    ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message); \
};
 
EXCEPTION_NAMESPACE(, System) {
    DECLARE_INHERITED_EXCEPTION_MSG(SystemException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG(ApplicationException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG(InvalidOperationException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG2(InvalidProgramException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG(InvalidTimeZoneException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG(TimeZoneNotFoundException, System::Details_Exception);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_NON_NULL_MEMBER(ObjectDisposedException, System::Details_InvalidOperationException, ObjectName);
    DECLARE_INHERITED_EXCEPTION_MSG(NotImplementedException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(NotSupportedException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(PlatformNotSupportedException, System::Details_NotSupportedException);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER(ArgumentException, System::Details_SystemException, ParamName);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER2(ArgumentNullException, System::Details_ArgumentException, ParamName);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER2(ArgumentOutOfRangeException, System::Details_ArgumentException, ParamName);
    DECLARE_INHERITED_EXCEPTION_MSG(FormatException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG2(UriFormatException, System::Details_FormatException);
    DECLARE_INHERITED_EXCEPTION_MSG(ArithmeticException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(OverflowException, System::Details_ArithmeticException);
    DECLARE_INHERITED_EXCEPTION_MSG(DivideByZeroException, System::Details_ArithmeticException);
    DECLARE_INHERITED_EXCEPTION_MSG(OutOfMemoryException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG2(IndexOutOfRangeException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(RankException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_HRESULT(InvalidCastException, System::Details_SystemException, (int32_t)2147500034u);
    DECLARE_INHERITED_EXCEPTION_MSG(NullReferenceException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG2(UnauthorizedAccessException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(MemberAccessException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(MethodAccessException, System::Details_MemberAccessException);
    DECLARE_INHERITED_EXCEPTION_MSG(OperationCanceledException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG2(StackOverflowException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG(TimeoutException, System::Details_SystemException);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_HRESULT(ExecutionEngineException, System::Details_SystemException, (int32_t)2148734214u);
    DECLARE_INHERITED_EXCEPTION_MSG_AND_SUBSTITUTE_NON_NULL_MEMBER(TypeInitializationException, System::Details_SystemException, TypeName);
    DECLARE_INHERITED_EXCEPTION_MSG(DataMisalignedException, System::Details_SystemException);
 
    EXCEPTION_NAMESPACE(System, IO) {
        DECLARE_INHERITED_EXCEPTION_MSG(IOException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION_MSG(EndOfStreamException, System::IO::Details_IOException);
        DECLARE_INHERITED_EXCEPTION_MSG2(InvalidDataException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION_MSG(DirectoryNotFoundException, System::IO::Details_IOException);
        DECLARE_INHERITED_EXCEPTION_MSG_AND_EXTRA_MEMBER(FileLoadException, System::IO::Details_IOException, FileName);
        DECLARE_INHERITED_EXCEPTION_MSG(PathTooLongException, System::IO::Details_IOException);
        DECLARE_INHERITED_EXCEPTION_MSG(DriveNotFoundException, System::IO::Details_IOException);
    }
 
    EXCEPTION_NAMESPACE(System, Globalization) {
        class Details_CultureNotFoundException;
        using CultureNotFoundException = System::ExceptionWrapper<Details_CultureNotFoundException>;
 
        class ASPOSECPP_SHARED_CLASS Details_CultureNotFoundException : public System::Details_ArgumentException {
            friend class System::ExceptionWrapperHelper;
            template <typename T> friend class System::ExceptionWrapper;
            RTTI_INFO_NAMESPACE(CultureNotFoundException, System::BaseTypesInfo<System::Details_ArgumentException>)
        public:
            virtual Nullable<int> get_InvalidCultureId() const { return m_invalid_culture_id; }
            virtual String get_InvalidCultureName() const { return m_invalid_culture_name; }
        protected:
            using BaseType = System::Details_ArgumentException;
            Details_CultureNotFoundException() : System::Details_ArgumentException(MessageDefault()) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException, CODEPORTING_ARGS(), CODEPORTING_ARGS());
            Details_CultureNotFoundException(const String& message) : System::Details_ArgumentException(DefaultMessageIfNull(message)) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException, CODEPORTING_ARGS(const String& message), CODEPORTING_ARGS(message));
            Details_CultureNotFoundException(const String& paramName, const String& message) : System::Details_ArgumentException(DefaultMessageIfNull(message), paramName) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException, CODEPORTING_ARGS(const String& paramName, const String& message), CODEPORTING_ARGS(paramName, message));
            Details_CultureNotFoundException(const String& message, const System::ExceptionWrapper<System::Details_Exception>& innerException) : System::Details_ArgumentException(DefaultMessageIfNull(message), innerException) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException,
                CODEPORTING_ARGS(const String& message, const System::ExceptionWrapper<System::Details_Exception>& innerException),
                CODEPORTING_ARGS(message, innerException)
            );
            Details_CultureNotFoundException(const String& paramName, int invalidCultureId, const String& message) : System::Details_ArgumentException(DefaultMessageIfNull(message), paramName), m_invalid_culture_id(invalidCultureId) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException, CODEPORTING_ARGS(const String& paramName, int invalidCultureId, const String& message), CODEPORTING_ARGS(paramName, invalidCultureId, message));
            Details_CultureNotFoundException(const String& message, int invalidCultureId, const System::ExceptionWrapper<System::Details_Exception>& innerException) : System::Details_ArgumentException(DefaultMessageIfNull(message), innerException), m_invalid_culture_id(invalidCultureId) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException,
                CODEPORTING_ARGS(const String& message, int invalidCultureId, const System::ExceptionWrapper<System::Details_Exception>& innerException),
                CODEPORTING_ARGS(message, invalidCultureId, innerException)
            );
            Details_CultureNotFoundException(const String& paramName, const String& invalidCultureName, const String& message) : System::Details_ArgumentException(DefaultMessageIfNull(message), paramName), m_invalid_culture_name(invalidCultureName) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException,
                CODEPORTING_ARGS(const String& paramName, const String& invalidCultureName, const String& message),
                CODEPORTING_ARGS(paramName, invalidCultureName, message)
            );
            Details_CultureNotFoundException(const String& message, const String& invalidCultureName, const System::ExceptionWrapper<System::Details_Exception>& innerException) : System::Details_ArgumentException(DefaultMessageIfNull(message), innerException), m_invalid_culture_name(invalidCultureName) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException,
                CODEPORTING_ARGS(const String& message, const String& invalidCultureName, const System::ExceptionWrapper<System::Details_Exception>& innerException),
                CODEPORTING_ARGS(message, invalidCultureName, innerException)
            );
            Details_CultureNotFoundException(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : System::Details_ArgumentException(info, context) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_CultureNotFoundException,
                CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context),
                CODEPORTING_ARGS(info, context)
            );
            [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_CultureNotFoundException>(self); }
        private:
            Nullable<int> m_invalid_culture_id;
            String m_invalid_culture_name;
            ASPOSECPP_SHARED_API static const String& MessageDefault();
            ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message);
        };
    }
 
    EXCEPTION_NAMESPACE(System, Security) {
        DECLARE_INHERITED_EXCEPTION_MSG(SecurityException, System::Details_SystemException);
 
        EXCEPTION_NAMESPACE(System::Security, Cryptography) {
            DECLARE_INHERITED_EXCEPTION_MSG(CryptographicException, System::Details_SystemException);
            DECLARE_INHERITED_EXCEPTION_MSG(CryptographicUnexpectedOperationException,
                                            System::Security::Cryptography::Details_CryptographicException);
        }
 
        EXCEPTION_NAMESPACE(System::Security, Authentication) 
        {
            DECLARE_INHERITED_EXCEPTION_MSG(AuthenticationException, System::Details_SystemException);
        }
    }
 
    EXCEPTION_NAMESPACE(System, Threading) {
        DECLARE_INHERITED_EXCEPTION_MSG(ThreadStateException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION_MSG(SemaphoreFullException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION_MSG(SynchronizationLockException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION(ThreadAbortException, System::Details_SystemException);
        DECLARE_INHERITED_EXCEPTION_MSG(ThreadInterruptedException, System::Details_SystemException);
    }
 
    EXCEPTION_NAMESPACE(System, ComponentModel)
    {
        class Details_InvalidEnumArgumentException;
        using InvalidEnumArgumentException = System::ExceptionWrapper<Details_InvalidEnumArgumentException>;
 
        class ASPOSECPP_SHARED_CLASS Details_InvalidEnumArgumentException : public System::Details_ArgumentException {
            friend class System::ExceptionWrapperHelper;
            template <typename T> friend class System::ExceptionWrapper;
            RTTI_INFO_NAMESPACE(InvalidEnumArgumentException, System::BaseTypesInfo<System::Details_ArgumentException>)
        protected:
            using BaseType = System::Details_ArgumentException;
 
            Details_InvalidEnumArgumentException() : System::Details_ArgumentException(MessageDefault()) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_InvalidEnumArgumentException, CODEPORTING_ARGS(), CODEPORTING_ARGS());
 
            Details_InvalidEnumArgumentException(const String& message) : System::Details_ArgumentException(DefaultMessageIfNull(message)) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_InvalidEnumArgumentException, CODEPORTING_ARGS(const String& message), CODEPORTING_ARGS(message));
 
            Details_InvalidEnumArgumentException(const String& message, const System::ExceptionWrapper<System::Details_Exception>& innerException) : System::Details_ArgumentException(DefaultMessageIfNull(message), innerException) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_InvalidEnumArgumentException,
                CODEPORTING_ARGS(const String& message, const System::ExceptionWrapper<System::Details_Exception>& innerException),
                CODEPORTING_ARGS(message, innerException)
            );
 
            Details_InvalidEnumArgumentException(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context) : System::Details_ArgumentException(info, context) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_InvalidEnumArgumentException,
                CODEPORTING_ARGS(const System::SharedPtr<System::Runtime::Serialization::SerializationInfo>& info, System::Runtime::Serialization::StreamingContext context),
                CODEPORTING_ARGS(info, context)
            );
 
            Details_InvalidEnumArgumentException(const String& argumentName, int invalidValue, const System::TypeInfo& enumClass)
                : System::Details_ArgumentException(DetailedMessage(argumentName, invalidValue, enumClass), argumentName) {}
            MEMBER_FUNCTION_MAKE_OBJECT(Details_InvalidEnumArgumentException,
                CODEPORTING_ARGS(const String& argumentName, int invalidValue, const System::TypeInfo& enumClass),
                CODEPORTING_ARGS(argumentName, invalidValue, enumClass));
 
            [[noreturn]] void DoThrow(const System::ExceptionPtr& self) const override { throw System::ExceptionWrapper<Details_InvalidEnumArgumentException>(self); }
        private:
            ASPOSECPP_SHARED_API static const String& MessageDefault();
            ASPOSECPP_SHARED_API static const String& DefaultMessageIfNull(const String& message);
            ASPOSECPP_SHARED_API static const String DetailedMessage(const String& argumentName, int invalidValue, const System::TypeInfo& enumClass);
        };
    }
 
    EXCEPTION_NAMESPACE(System, Collections)
    {
        EXCEPTION_NAMESPACE(System::Collections, Generic)
        {
            DECLARE_INHERITED_EXCEPTION_MSG(KeyNotFoundException, System::Details_SystemException);
        }
    }
 
    EXCEPTION_NAMESPACE(System, Web)
    {
        DECLARE_INHERITED_EXCEPTION(HttpException, System::Details_Exception);
    }
 
    EXCEPTION_NAMESPACE(System, Runtime)
    {
        EXCEPTION_NAMESPACE(System::Runtime, Serialization)
        {
            DECLARE_INHERITED_EXCEPTION_MSG(SerializationException, System::Details_SystemException);
        }
    }
}
 
EXCEPTION_NAMESPACE(,NUnit)
{
    EXCEPTION_NAMESPACE(NUnit, Framework)
    {
            using System::SystemException;
            DECLARE_INHERITED_EXCEPTION(AssertionException, System::Details_SystemException);
    }
}
 
#define CODEPORTING_USER_EXCEPTION_BEGIN(ns, name, base) class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class Details_##name : public base \
{ \
    typedef Details_##name ThisType; \
    typedef base BaseType; \
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; \
    RTTI_INFO_NAMED(Details_##name, #ns"::"#name, ThisTypeBaseTypesInfo); \
    friend class ::System::ExceptionWrapperHelper; \
    template <typename T> friend class ::System::ExceptionWrapper; \
protected: \
    [[noreturn]] void DoThrow(const ::System::ExceptionPtr& self) const override \
    { \
        throw ::System::ExceptionWrapper<Details_##name>(self); \
    }
 
#define CODEPORTING_USER_EXCEPTION_END };
 
#define CODEPORTING_USER_EXCEPTION_CONSTRUCTOR(name, args_with_types, args_without_types) protected: \
MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(args_with_types), CODEPORTING_ARGS(args_without_types)); \
Details_##name(args_with_types)
 
#define CODEPORTING_DECLARE_USER_EXCEPTION_BEGIN(class_api, method_api, ns, name, base) class Details_##name; \
using name = System::ExceptionWrapper<Details_##name>; \
class class_api Details_##name : public base \
{ \
    typedef Details_##name ThisType; \
    typedef base BaseType; \
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; \
    RTTI_INFO_NAMED_DECLARE_EXPORTED(method_api, Details_##name, #ns"::"#name, ThisTypeBaseTypesInfo); \
    friend class ::System::ExceptionWrapperHelper; \
    template <typename T> friend class ::System::ExceptionWrapper; \
protected: \
    [[noreturn]] method_api void DoThrow(const ::System::ExceptionPtr& self) const override;
 
#define CODEPORTING_EXPORTED_USER_EXCEPTION_CONSTRUCTOR(method_api, name, args_with_types, args_without_types) protected: \
MEMBER_FUNCTION_MAKE_OBJECT(Details_##name, CODEPORTING_ARGS(args_with_types), CODEPORTING_ARGS(args_without_types)); \
method_api Details_##name(args_with_types);
 
#define CODEPORTING_USER_EXCEPTION_IMPLEMENTATION(class_api, method_api, ns, name, base) \
const ::System::TypeInfo& ns::Details_##name::Type() { \
    return *System::static_holder<ThisTypeInfo>(); \
} \
const System::TypeInfo& ns::Details_##name::GetType() const { \
    return Details_##name::Type(); \
} \
bool ns::Details_##name::Is(const System::TypeInfo &target) const { \
    const System::TypeInfo& thisis = Details_##name::Type(); \
    return (thisis == target) ? true : ThisTypeBaseTypesInfo::CallIsForAll(this, target); \
} \
[[noreturn]] void ns::Details_##name::DoThrow(const ::System::ExceptionPtr& self) const \
{ \
    throw ::System::ExceptionWrapper<Details_##name>(self); \
} \
ns::Details_##name::ThisTypeInfo::ThisTypeInfo() \
    : System::TypeInfoPtr(ASPOSE_T(#ns) ASPOSE_T(#name), 0) \
{ \
}