GCException.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (c) 2004 by Basler Vision Technologies
//  Section: Vision Components
//  Project: GenICam
//  Author:  Fritz Dierks
//  $Header$
//
//  01.10.2014 Stemmer, SD
//             prepared for remove of std::exception base class 
//
//  14.03.2005 Stemmer, RS
//             changed minor things like namespace
//             added a AccessException
//             added a TimeoutException
//
//  21.02.2006 Stemmer, SD
//             used _vsnprintf_s function for VS8 and higher (compiler fork)
//
//  License: This file is published under the license of the EMVA GenICam  Standard Group.
//  A text file describing the legal terms is included in  your installation as 'GenICam_license.pdf'.
//  If for some reason you are missing  this file please contact the EMVA or visit the website
//  (http://www.genicam.org) for a full copy.
//
//  THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
//  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD  GROUP
//  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL,
//  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT  LIMITED TO,
//  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,  DATA, OR PROFITS;
//  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY  THEORY OF LIABILITY,
//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE)
//  ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//  POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
#ifndef GENCAM_EXCEPTION_H_
#define GENCAM_EXCEPTION_H_
 
#include <cassert>
#include <cstdarg>
#include <exception>
#include <sstream>
#include <stdio.h>
#include <stdarg.h>
#include <Base/GCTypes.h>
#include <Base/GCString.h>
#include <Base/GCCompatibility.h>
 
#pragma pack(push, 8)
 
namespace GENICAM_NAMESPACE
{
    class GCBASE_RTTI_CLASS_API GenericException 
    {
    public:
        GenericException(const char* pDescription, const char *pSourceFileName, unsigned int SourceLine);
 
        GenericException(const char* pDescription, const char *pSourceFileName, unsigned int SourceLine, const char* pExceptionType);
 
        GenericException(const char* pDescription, const char *pSourceFileName, unsigned int SourceLine, const char *pEntryPoint, const char *pErrorNodeName, const char* pExceptionType);
 
        virtual const char* GetDescription() const throw();
 
        virtual const char* GetSourceFileName() const throw();
 
        virtual unsigned int GetSourceLine() const throw();
 
        virtual const char *what() const throw();
 
        virtual ~GenericException() throw();
 
    private:
 
        void AssembleMessage();
 
        GENICAM_NAMESPACE::gcstring m_What;
 
        GENICAM_NAMESPACE::gcstring m_ExceptionType;
 
        unsigned int m_SourceLine;
 
        GENICAM_NAMESPACE::gcstring m_SourceFileName;
 
        GENICAM_NAMESPACE::gcstring m_Description;
 
        /* the following members are GenApi specific */
 
        GENICAM_NAMESPACE::gcstring m_EntryPoint;
 
        GENICAM_NAMESPACE::gcstring m_ErrorNodeName;
    };
 
#define DECLARE_EXCEPTION( name ) \
        class GCBASE_RTTI_CLASS_API name : public GENICAM_NAMESPACE::GenericException \
            { \
        public: \
            name( const char* pDescription, const char *pSourceFileName, int SourceLine ); \
            name( const char* pDescription, const char *pSourceFileName, int SourceLine, const char* pExceptionType  ); \
            name( const char* pDescription, const char *pSourceFileName, int SourceLine, const char *pEntryPoint, const char *pErrorNodeName, const char* pExceptionType ); \
            }
 
    
    DECLARE_EXCEPTION(BadAllocException);
 
    DECLARE_EXCEPTION(InvalidArgumentException);
 
    DECLARE_EXCEPTION(OutOfRangeException);
 
    DECLARE_EXCEPTION(PropertyException);
 
    DECLARE_EXCEPTION(RuntimeException);
 
    DECLARE_EXCEPTION(LogicalErrorException);
 
    DECLARE_EXCEPTION(AccessException);
 
    DECLARE_EXCEPTION(TimeoutException);
 
    DECLARE_EXCEPTION(DynamicCastException);
 
 
    /*-----------------------------------------------------------------*/
    // Utilities
    /*-----------------------------------------------------------------*/
 
    template <typename E>
    class ExceptionReporter
    {
    public:
 
        ExceptionReporter(const char* pSourceFileName, int SourceLine)
            : m_SourceFileName(pSourceFileName)
            , m_SourceLine(SourceLine)
        {
        }
 
        ExceptionReporter(const char* pSourceFileName, int SourceLine, const char* pExceptionType)
            : m_SourceFileName(pSourceFileName)
            , m_SourceLine(SourceLine)
            , m_ExceptionType(pExceptionType)
        {
        }
 
        E Report(const char* pFormat, ...)
        {
            char pBuffer[2048];
            va_list vap;
            va_start(vap, pFormat);
 
#               if defined (_MSC_VER)
            vsnprintf_s(pBuffer, sizeof pBuffer, _TRUNCATE, pFormat, vap);
#               else 
            vsnprintf( pBuffer, sizeof pBuffer, pFormat, vap );
#               endif 
 
            va_end(vap);
 
            return E(pBuffer, m_SourceFileName.c_str(), m_SourceLine, m_ExceptionType.c_str());
        };
 
        E Report()
        {
            return E("", m_SourceFileName.c_str(), m_SourceLine, m_ExceptionType.c_str());
        }
 
        E Report(const std::string &s)
        {
            return E(s.c_str(), m_SourceFileName.c_str(), m_SourceLine, m_ExceptionType.c_str());
        }
 
        E Report(const std::stringstream& str)
        {
            return E(str.str().c_str(), m_SourceFileName.c_str(), m_SourceLine, m_ExceptionType.c_str());
        }
 
    protected:
        GENICAM_NAMESPACE::gcstring m_SourceFileName;
 
        int m_SourceLine;
 
        GENICAM_NAMESPACE::gcstring m_ExceptionType;
    };
 
 
    #define GENERIC_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::GenericException>(__FILE__, __LINE__).Report
 
    #define BAD_ALLOC_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::BadAllocException>(__FILE__, __LINE__, "BadAllocException" ).Report
 
    #define INVALID_ARGUMENT_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::InvalidArgumentException>(__FILE__, __LINE__, "InvalidArgumentException" ).Report
 
    #define OUT_OF_RANGE_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::OutOfRangeException>(__FILE__, __LINE__, "OutOfRangeException" ).Report
 
    #define PROPERTY_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::PropertyException>(__FILE__, __LINE__, "PropertyException" ).Report
 
    #define RUNTIME_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::RuntimeException>(__FILE__, __LINE__, "RuntimeException" ).Report
 
    #define LOGICAL_ERROR_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::LogicalErrorException>(__FILE__,  __LINE__, "LogicalErrorException" ).Report
 
    #define ACCESS_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::AccessException>(__FILE__, __LINE__, "AccessException" ).Report
 
    #define TIMEOUT_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::TimeoutException>(__FILE__, __LINE__,"TimeoutException" ).Report
 
    #define DYNAMICCAST_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::DynamicCastException>(__FILE__, __LINE__, "DynamicCastException" ).Report
 
    #define CHECK_RANGE_I64(_Value, _Min, _Max, _Inc) \
        if((int64_t)(_Value) < (int64_t)(_Min)) \
            throw OUT_OF_RANGE_EXCEPTION("Value = %" FMT_I64 "d must be equal or greater than Min = %" FMT_I64 "d", (int64_t)(_Value), (int64_t)(_Min)); \
                else if((int64_t)(_Value) > (int64_t)(_Max)) \
            throw OUT_OF_RANGE_EXCEPTION("Value = %" FMT_I64 "d must be equal or smaller than Max = %" FMT_I64 "d", (int64_t)(_Value), (int64_t)(_Max)); \
                else if ( 0 == _Inc ) \
            throw LOGICAL_ERROR_EXCEPTION("Increment must not equal 0!"); \
                else if( ((int64_t)(_Value) - (int64_t)(_Min)) % (int64_t)(_Inc) != 0) \
            throw OUT_OF_RANGE_EXCEPTION("The difference between Value = %" FMT_I64 "d and Min = %" FMT_I64 "d must be dividable without rest by Inc = %" FMT_I64 "d", (int64_t)(_Value), (int64_t)(_Min), (int64_t)(_Inc));
 
    #define CHECK_RANGE_FLT(_Value, _Min, _Max) \
        if ((_Value) < (_Min)) \
            throw OUT_OF_RANGE_EXCEPTION( "Value %f must be greater than or equal %f", (_Value), (_Min) ); \
        else if ((_Value) > (_Max)) \
            throw OUT_OF_RANGE_EXCEPTION( "Value %f must be smaller than or equal %f", (_Value), (_Max) );
 
    #define CHECK_DYNAMIC_CAST_POINTER( _Pointer )\
        assert( (_Pointer) != NULL ); \
        if (NULL == (_Pointer)) throw LOGICAL_ERROR_EXCEPTION( "Unexpected type in dynamic cast" )
 
 
}
 
#pragma pack(pop)
 
#endif // GENCAM_EXCEPTION_H_