exceptions.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#include <stdio.h>
#include <ogdf/basic/basic.h>


#ifndef OGDF_EXCEPTIONS_H
#define OGDF_EXCEPTIONS_H


namespace ogdf {

#ifdef OGDF_DEBUG

#define OGDF_THROW_WITH_INFO
#endif

#ifdef OGDF_THROW
#undef OGDF_THROW
#endif

#ifndef OGDF_THROW_WITH_INFO
#define OGDF_THROW_PARAM(CLASS, PARAM) throw CLASS ( PARAM )
#define OGDF_THROW(CLASS)              throw CLASS ( )
#else


#define OGDF_THROW_PARAM(CLASS, PARAM) throw CLASS ( PARAM , __FILE__ , __LINE__ )


#define OGDF_THROW(CLASS)              throw CLASS ( __FILE__ , __LINE__ )
#endif



    enum PreconditionViolatedCode {
        pvcUnknown,
        pvcSelfLoop,          
        pvcTreeHierarchies,   
        pvcAcyclicHierarchies,
        pvcSingleSource,      
        pvcUpwardPlanar,      
        pvcTree,              
        pvcForest,            
        pvcOrthogonal,        
        pvcPlanar,            
        pvcClusterPlanar,     
        pvcNoCopy,            
        pvcConnected,         
        pvcBiconnected,         
        pvcSTOP               // INSERT NEW CODES BEFORE pvcSTOP!
    }; // enum PreconditionViolatedCode



    enum AlgorithmFailureCode {
        afcUnknown,
        afcIllegalParameter, 
        afcNoFlow,           
        afcSort,             
        afcLabel,            
        afcExternalFace,     
        afcForbiddenCrossing,
        afcTimelimitExceeded,
        afcNoSolutionFound,  
        afcSTOP              // INSERT NEW CODES BEFORE afcSTOP!
    }; // enum AlgorithmFailureCode




    enum LibraryNotSupportedCode {
        lnscUnknown,
        lnscCoin,                          
        lnscAbacus,                        
        lnscFunctionNotImplemented,        
        lnscMissingCallbackImplementation, //
        lnscSTOP                           // INSERT NEW CODES BEFORE nscSTOP!
    }; // enum AlgorithmFailureCode



    class OGDF_EXPORT Exception { 

    private:

        const char *m_file; 
        int         m_line; 

    public:

        Exception(const char *file = NULL, int line = -1) : 
          m_file(file),
          m_line(line)
        {}


        const char *file() { return m_file; }
        

        int line() { return m_line; }
    };


    class OGDF_EXPORT DynamicCastFailedException : public Exception {

    public:
        DynamicCastFailedException(const char *file = NULL, int line = -1) : Exception(file, line) {}
    };


    class OGDF_EXPORT InsufficientMemoryException : public Exception {

    public:
        InsufficientMemoryException(const char *file = NULL, int line = -1) : Exception(file, line) {}
    };



    class OGDF_EXPORT NoStdComparerException : public Exception {

    public:
        NoStdComparerException(const char *file = NULL, int line = -1) : Exception(file, line) {}
    };


    class OGDF_EXPORT PreconditionViolatedException : public Exception 
    {
    public:
        PreconditionViolatedException(PreconditionViolatedCode code,
            const char *file = NULL,
            int line = -1) :
        Exception(file, line),
        m_exceptionCode(code)
        {}

        PreconditionViolatedException(
            const char *file = NULL,
            int line = -1) :
        Exception(file, line),
        m_exceptionCode(pvcUnknown)
        {}

        PreconditionViolatedCode exceptionCode() const { return m_exceptionCode; }

    private:
        PreconditionViolatedCode m_exceptionCode; 
    }; // class PreconditionViolatedException



    class OGDF_EXPORT AlgorithmFailureException : public Exception
    {
    public:

        AlgorithmFailureException(AlgorithmFailureCode code,
            const char *file = NULL,
            int line = -1) :
        Exception(file, line),
        m_exceptionCode(code)
        {}

        AlgorithmFailureException(
            const char *file = NULL,
            int line = -1) :
        Exception(file, line),
        m_exceptionCode(afcUnknown)
        {}

        AlgorithmFailureCode exceptionCode() const { return m_exceptionCode; }

    private:
        AlgorithmFailureCode m_exceptionCode; 
    }; // class AlgorithmFailureException



    class OGDF_EXPORT LibraryNotSupportedException : public Exception {
        public:
            LibraryNotSupportedException(LibraryNotSupportedCode code,
                const char *file = NULL,
                int line = -1) :
            Exception(file, line),
            m_exceptionCode(code)
            {}
                
            LibraryNotSupportedException(
                const char *file = NULL,
                int line = -1) :
            Exception(file, line),
            m_exceptionCode(lnscUnknown)
            {}

        LibraryNotSupportedCode exceptionCode() const { return m_exceptionCode; }

    private:
        LibraryNotSupportedCode m_exceptionCode; 
    }; // class LibraryNotSupportedException

} // end namespace ogdf


#endif