vexception.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vexception_h
#define vexception_h

#include "vstring.h"
#include "vlogger.h"
#include "vthread.h"

class VSystemError {

    public:

        VSystemError();
        VSystemError(int errorCode);
        VSystemError(int errorCode, const VString& errorMessage);
        ~VSystemError() {}

        static VSystemError getSocketError();

        int getErrorCode() const { return mErrorCode; }
        VString getErrorMessage() const { return mErrorMessage; }
        bool isLikePosixError(int posixErrorCode) const { return this->_isLikePosixError(posixErrorCode); }

    private:

        // Platform-specific implementations for obtaining system and socket error codes and messages.
        // The implementation for these is in each platform's vtypes_platform.cpp file.
        static int _getSystemErrorCode();
        static int _getSocketErrorCode();
        static VString _getSystemErrorMessage(int errorCode);
        
        bool _isLikePosixError(int posixErrorCode) const;

        int     mErrorCode;     
        VString mErrorMessage;  
};

class VException : public std::exception {
    public:

        VException(bool recordStackTrace = false);
        VException(const VException& other, bool recordStackTrace = false);
        VException(int error, const char* errorMessage, bool recordStackTrace = false);
        VException(int error, const VString& errorString, bool recordStackTrace = false);
        VException(const char* errorMessage, bool recordStackTrace = false);
        VException(const VString& errorString, bool recordStackTrace = false);
        VException(const VSystemError& error, const VString& errorString, bool recordStackTrace = false);
        virtual ~VException() throw();

        VException& operator=(const VException& other);

        virtual const char* what() const throw();

        int getError() const;

        static const int kGenericError = -1;    

        const VStringVector& getStackTrace() const;

    private:

        void _assertInvariant() const;

        void _recordStackTrace();

        static void _breakpointLocation();

        int         mError;         
        VString     mErrorString;   
        const char* mErrorMessage;  
        VStringVector mStackTrace;   
};

class VStackTraceException : public VException {
    public:

        VStackTraceException(const VString& errorString) :
            VException(errorString, true) {}
        VStackTraceException(int error, const VString& errorString) :
            VException(error, errorString, true) {}
        VStackTraceException(const VSystemError& error, const VString& errorString) :
            VException(error, errorString, true) {}
        virtual ~VStackTraceException() throw() {}
};

class VEOFException : public VException {
    public:

        VEOFException(const char* errorMessage) : VException(errorMessage) {}
        VEOFException(const VString& errorString) : VException(errorString) {}
        virtual ~VEOFException() throw() {}
};

class VSocketClosedException : public VException {
    public:

        VSocketClosedException(int error, const VString& errorString) : VException(error, errorString) {}
        VSocketClosedException(const VSystemError& error, const VString& errorString) : VException(error, errorString) {}
        virtual ~VSocketClosedException() throw() {}
};

class VRangeException : public VException {
    public:

        VRangeException(const char* errorMessage, bool recordStackTrace = true) : VException(errorMessage, recordStackTrace) {}
        VRangeException(const VString& errorString, bool recordStackTrace = true) : VException(errorString, recordStackTrace) {}
        virtual ~VRangeException() throw() {}
};

class VUnimplementedException : public VException {
    public:

        VUnimplementedException(const char* errorMessage, bool recordStackTrace = true) : VException(errorMessage, recordStackTrace) {}
        VUnimplementedException(const VString& errorString, bool recordStackTrace = true) : VException(errorString, recordStackTrace) {}
        virtual ~VUnimplementedException() throw() {}
};

#ifdef VAULT_CORE_FOUNDATION_SUPPORT

class VOSStatusException : public VException {
    public:

        static void throwIfError(OSStatus err, const VString& message, bool recordStackTrace = true) { if (0 != err) throw VOSStatusException(err, message, recordStackTrace); }

        VOSStatusException(OSStatus err, const VString& message, bool recordStackTrace = true) : VException(static_cast<int>(err), message, recordStackTrace) {}
        virtual ~VOSStatusException() throw() {}
};

#endif /* VAULT_CORE_FOUNDATION_SUPPORT */

template<typename cast_to_type, typename an_object_ptr>
static cast_to_type VcheckedDynamicCast(an_object_ptr& obj, const char* file, int line, bool rethrowException, bool logException, bool logStackCrawl) {
    try {
        return dynamic_cast<cast_to_type>(obj);
    } catch (const std::exception& ex) {
        // Avoid message construction overhead if no flags require it.
        if (logException || rethrowException) {
            VString message(VSTRING_ARGS("Exception in dynamic_cast operation at %s:%d: '%s'", file, line, ex.what()));

            if (logException) {
                if (logStackCrawl) {
                    VThread::logStackCrawl(message, VLogger::getDefaultLogger(), false);
                }

                VLogger::getDefaultLogger()->log(VLoggerLevel::ERROR, file, line, message);
            }

            if (rethrowException) {
                throw VException(message);
            }
        }

        return NULL;
    }
}

#define V_CHECKED_DYNAMIC_CAST(cast_to_type, an_object) VcheckedDynamicCast<cast_to_type>((an_object), __FILE__, __LINE__, true, true, true)

#define V_CHECKED_DYNAMIC_CAST_NOTHROW(cast_to_type, an_object) VcheckedDynamicCast<cast_to_type>((an_object), __FILE__, __LINE__, false, true, true)

#endif /* vexception_h */