Exception.h

#pragma once


#include <libutl/Object.h>


UTL_NS_BEGIN;


void errToEx(const utl::Object* object = nullptr);


void h_errToEx(const utl::Object* object = nullptr);


class String;


#define UTL_EXCEPTION_DECL(exName, baseExName)                                                     \
    class exName : public baseExName                                                               \
    {                                                                                              \
        UTL_CLASS_DECL(exName, baseExName);                                                        \
                                                                                                   \
    public:                                                                                        \
        exName(utl::Object* object);                                                               \
                                                                                                   \
        exName(const utl::Object& object);                                                         \
                                                                                                   \
        exName(const char* name, utl::Object* object)                                              \
            : baseExName(name, object)                                                             \
        {                                                                                          \
        }                                                                                          \
                                                                                                   \
        exName(const char* name, const utl::Object& object)                                        \
            : baseExName(name, object)                                                             \
        {                                                                                          \
        }                                                                                          \
                                                                                                   \
    private:                                                                                       \
        void init();                                                                               \
        void                                                                                       \
        deInit()                                                                                   \
        {                                                                                          \
        }                                                                                          \
    };


#define UTL_EXCEPTION_IMPL(exNS, exName, baseExName, name)                                         \
    UTL_CLASS_IMPL(exNS::exName);                                                                  \
    exNS::exName::exName(utl::Object* object)                                                      \
        : baseExName(name, object)                                                                 \
    {                                                                                              \
    }                                                                                              \
                                                                                                   \
    exNS::exName::exName(const utl::Object& object)                                                \
        : baseExName(name, object)                                                                 \
    {                                                                                              \
    }                                                                                              \
                                                                                                   \
    void exNS::exName::init()                                                                      \
    {                                                                                              \
        setName(name);                                                                             \
    }

// Exception ///////////////////////////////////////////////////////////////////////////////////////


class Exception : public Object
{
    UTL_CLASS_DECL_ABC(Exception, Object);

public:
    Exception(const char* name, Object* object);

    Exception(const char* name, const Object& object);

    virtual void copy(const Object& rhs);

    virtual void dump(Stream& os) const;

    const String&
    name() const
    {
        ASSERTD(_name != nullptr);
        return *_name;
    }

    const String*
    namePtr() const
    {
        return _name;
    }

    void setName(const char* name);

    Object*
    object() const
    {
        return _object;
    }

    Object*
    takeObject()
    {
        Object* obj = _object;
        _object = nullptr;
        return obj;
    }

    void setObject(Object* object);

    void setObject(const Object& object);

private:
    void init();
    void deInit();

private:
    const String* _name;
    Object* _object;
};

// Host OS Exceptions //////////////////////////////////////////////////////////////////////////////

UTL_EXCEPTION_DECL(HostOSEx, utl::Exception);

UTL_EXCEPTION_DECL(AccessDeniedEx, HostOSEx);

UTL_EXCEPTION_DECL(FileExistsEx, HostOSEx);

UTL_EXCEPTION_DECL(FileNotFoundEx, HostOSEx);

UTL_EXCEPTION_DECL(InterruptedSyscallEx, HostOSEx);

UTL_EXCEPTION_DECL(InvalidAddressEx, HostOSEx);

UTL_EXCEPTION_DECL(NonDirectoryComponentEx, HostOSEx);

UTL_EXCEPTION_DECL(UnknownHostOSEx, HostOSEx);

// Stream Exceptions ///////////////////////////////////////////////////////////////////////////////

UTL_EXCEPTION_DECL(StreamEx, Exception);

UTL_EXCEPTION_DECL(StreamEOFex, StreamEx);

UTL_EXCEPTION_DECL(StreamErrorEx, StreamEx);

UTL_EXCEPTION_DECL(StreamSerializeEx, StreamEx);

// Network Exceptions //////////////////////////////////////////////////////////////////////////////

UTL_EXCEPTION_DECL(NetworkEx, HostOSEx);

UTL_EXCEPTION_DECL(ConnectionRefusedEx, NetworkEx);

UTL_EXCEPTION_DECL(AddressInUseEx, NetworkEx);

UTL_EXCEPTION_DECL(AddressNotAvailableEx, NetworkEx);

UTL_EXCEPTION_DECL(NetworkUnreachableEx, NetworkEx);

UTL_EXCEPTION_DECL(ConnectionResetEx, NetworkEx);

UTL_EXCEPTION_DECL(HostLookupEx, NetworkEx);

UTL_EXCEPTION_DECL(HostNoAddressEx, NetworkEx);

UTL_EXCEPTION_DECL(HostNotFoundEx, NetworkEx);

// Misc Exceptions /////////////////////////////////////////////////////////////////////////////////

UTL_EXCEPTION_DECL(IllegalValueEx, Exception);

UTL_EXCEPTION_DECL(UnknownEx, Exception);


UTL_NS_END;