---

NSXException.h

Go to the documentation of this file.

/****************************************************************************************
    NSXException.h $Revision: 1.4 $
    
    Copyright (c) 2002 Red Shed Software. All rights reserved.
    by Jonathan 'Wolf' Rentzsch (jon * redshed * net)
    
    ************************************************************************************/

/************************************************************************************/
#ifndef     _NSXException_
#define     _NSXException_

#include    <Cocoa/Cocoa.h>
#include    <exception>
#include    <typeinfo>

/****************************************************************************************
*   
*   Classes
*   
****************************************************************************************/
#pragma mark    (Classes)

/************************************************************************************/
class   NSXException : public std::exception {
public:
    NSXException(
        NSException *nsexception )
    :   nsexception_( nsexception ){}
    
        NSException*
    nsexception() const
    {   return nsexception_; }
    
        void
    raise() const {
        [nsexception_ raise];
    }
    
        virtual
        const char*
    what() const throw() {
        return "NSXException";
    }
    
    /************************************************************************************/
        static
        NSException*
    NSExceptionForException(
        const   std::exception  *cppException )
    {
        const NSXException *nsxexception = dynamic_cast<const NSXException*>( cppException );
        if( nsxexception ) {
            //  It's a wrapped NSException -- unwrap it.
            return nsxexception->nsexception();
        } else {
            //  It's a C++ exception -- wrap it in an NSException.
            NSData *cppExceptionWrapper = [NSData dataWithBytes:&cppException length:sizeof(cppException)];
            NSDictionary *userInfo = [NSDictionary
                                        dictionaryWithObject: cppExceptionWrapper
                                        forKey:@"std::exception"];
            NSString *reason = [NSString stringWithFormat:@"%s: %s", typeid(cppException).name(), cppException->what()];
            return [NSException
                    exceptionWithName:@"NSException-wrapped std::exception"
                    reason:reason
                    userInfo:userInfo];
        }
    }

    /************************************************************************************/
        static
        void
    Raise(
        const   std::exception  *cppException )
    {
        [NSXException::NSExceptionForException( cppException ) raise];
    }
    
    /************************************************************************************/
        static
        void
    Throw(
        NSException *objCException )
    {
        NSDictionary *userInfo = [objCException userInfo];
        NSData *cppException = [userInfo valueForKey:@"std::exception"];
        if( cppException ) {
            std::exception *exception;
            [cppException getBytes:&exception];
            throw exception;
        } else {
            throw new NSXException( objCException );
        }
    }
private:
    NSException *nsexception_;
};

/************************************************************************************/
class   AutoNSExceptionHandler : public _NSHandler2 {
public:
    AutoNSExceptionHandler()
    :   installed_( true ) {
        _NSAddHandler2( this );
    }
    
    ~AutoNSExceptionHandler() {
        if( installed_ ) {
            _NSRemoveHandler2( this );
            installed_ = false;
        }
    }
    
    NSException* localException() {
        installed_ = false;
        return _NSExceptionObjectFromHandler2( this );
    }
private:
    bool    installed_;
};

/************************************************************************************/
class   NSXRaisingDestructor    {
public:
    NSXRaisingDestructor()
    :   nsexception_( nil ){}
    
    ~NSXRaisingDestructor() {
        if( nsexception_ != nil )
            [nsexception_ raise];
    }
    
    void arm( NSException *exception ) {
        nsexception_ = exception;
    }
    
    void arm( const std::exception *exception ) {
        nsexception_ = NSXException::NSExceptionForException( exception );
    }
private:
    NSException *nsexception_;
};

/****************************************************************************************
*   
*   Multiline Exception Morphing
*   
****************************************************************************************/
#pragma mark    -
#pragma mark    (Multiline Exception Morphing Macros)

/************************************************************************************/
#define NSX_THROW                                   \
    {                                               \
        AutoNSExceptionHandler  handler_;           \
        if( !_NSSETJMP( handler_._state, 0 ) ) {

/************************************************************************************/
#define NSX_ENDTHROW                                            \
        } else {                                                \
            NSXException::Throw( handler_.localException() );   \
        }                                                       \
    }

/************************************************************************************/
#define NSX_RAISE                                   \
    {                                               \
        NSXRaisingDestructor raisingDestructor;     \
        try {

/************************************************************************************/
#define NSX_ENDRAISE                            \
        } catch( const std::exception *x ) {    \
            raisingDestructor.arm( x );         \
        }                                       \
    }

/****************************************************************************************
*   
*   Single-line Exception Morphing Macros
*   
****************************************************************************************/
#pragma mark    -
#pragma mark    (Single-line Exception Morphing Macros)

/************************************************************************************/
#define ThrowNSX( CODE )                                        \
    {                                                           \
        AutoNSExceptionHandler  handler_;                       \
        if( !_NSSETJMP( handler_._state, 0 ) ) {                \
            CODE;                                               \
        } else {                                                \
            NSXException::Throw( handler_.localException() );   \
        }                                                       \
    }

/************************************************************************************/
#define RaiseNSX( CODE )                        \
    {                                           \
        NSXRaisingDestructor raisingDestructor; \
        try {                                   \
            CODE;                               \
        } catch( const std::exception *x ) {    \
            raisingDestructor.arm( x );         \
        }                                       \
    }

/****************************************************************************************
*   
*   Scope-Aware Version of NS_DURING. Typically you should use NSX_THROW instead.
*   
****************************************************************************************/
#pragma mark    -
#pragma mark    (Scope-Aware Version of NS_DURING)

/************************************************************************************/
#define NSX_DURING                                                      \
    {                                                                   \
        AutoNSExceptionHandler  handler_;                               \
        if( !_NSSETJMP( handler_._state, 0 ) ) {                        

/************************************************************************************/
#define NSX_HANDLER                                                     \
        } else {                                                        \
            NSException *localException = handler_.localException();    

/************************************************************************************/
#define NSX_ENDHANDLER                                                  \
            localException = localException;                            \
        }                                                               \
    }   
        
#endif  //  _NSXException_

---