Skip to content

Base/GCException.h#

Standard GenICam Exceptions.

Namespaces#

Name
GenICam
Contains definitions of GenICam types and exceptions.

Defines#

Name
DECLARE_EXCEPTION(name)
GENERIC_EXCEPTION
Fires a generic exception, e.g. throw GENERIC_EXCEPTION("%ld too large", Value);.
BAD_ALLOC_EXCEPTION
Fires a bad alloc exception, e.g. throw BAD_ALLOC_EXCEPTION();.
INVALID_ARGUMENT_EXCEPTION
Fires an invalid argument exception, e.g. throw INVALID_ARGUMENT_EXCEPTION("%ld too large", Value);.
OUT_OF_RANGE_EXCEPTION
Fires an out of range exception, e.g. throw OUT_OF_RANGE_EXCEPTION("%ld too large", Value);.
PROPERTY_EXCEPTION
Fires an property exception, e.g. throw PROPERTY_EXCEPTION("%ld too large", Value);.
RUNTIME_EXCEPTION
Fires a runtime exception, e.g. throw RUNTIME_EXCEPTION("buh!")
LOGICAL_ERROR_EXCEPTION
Fires a logical error exception, e.g. throw LOGICAL_ERROR_EXCEPTION("Should never reach this point")
ACCESS_EXCEPTION
Fires a access exception, e.g. throw ACCESS_EXCEPTION("Not everybody")
TIMEOUT_EXCEPTION
Fires a timeout error exception, e.g. throw TIMEOUT_EXCEPTION("Not everybody")
DYNAMICCAST_EXCEPTION
Fires a dynamic cast exception, e.g. throw DYNAMICCAST_EXCEPTION("Not everybody")
CHECK_RANGE_I64(_Value, _Min, _Max, _Inc)
Range check for int64.
CHECK_RANGE_FLT(_Value, _Min, _Max)
Range check for float.
CHECK_DYNAMIC_CAST_POINTER(_Pointer)
Checks if a dynamic_cast is possible.

Macros Documentation#

define DECLARE_EXCEPTION#

#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 ); \
            }

Creates an exception with the same functionality as the GenericException but being of different type

define GENERIC_EXCEPTION#

#define GENERIC_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::GenericException>(__FILE__, __LINE__).Report

Fires a generic exception, e.g. throw GENERIC_EXCEPTION("%ld too large", Value);.

define BAD_ALLOC_EXCEPTION#

#define BAD_ALLOC_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::BadAllocException>(__FILE__, __LINE__, "BadAllocException" ).Report

Fires a bad alloc exception, e.g. throw BAD_ALLOC_EXCEPTION();.

define INVALID_ARGUMENT_EXCEPTION#

#define INVALID_ARGUMENT_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::InvalidArgumentException>(__FILE__, __LINE__, "InvalidArgumentException" ).Report

Fires an invalid argument exception, e.g. throw INVALID_ARGUMENT_EXCEPTION("%ld too large", Value);.

define OUT_OF_RANGE_EXCEPTION#

#define OUT_OF_RANGE_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::OutOfRangeException>(__FILE__, __LINE__, "OutOfRangeException" ).Report

Fires an out of range exception, e.g. throw OUT_OF_RANGE_EXCEPTION("%ld too large", Value);.

define PROPERTY_EXCEPTION#

#define PROPERTY_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::PropertyException>(__FILE__, __LINE__, "PropertyException" ).Report

Fires an property exception, e.g. throw PROPERTY_EXCEPTION("%ld too large", Value);.

define RUNTIME_EXCEPTION#

#define RUNTIME_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::RuntimeException>(__FILE__, __LINE__, "RuntimeException" ).Report

Fires a runtime exception, e.g. throw RUNTIME_EXCEPTION("buh!")

define LOGICAL_ERROR_EXCEPTION#

#define LOGICAL_ERROR_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::LogicalErrorException>(__FILE__,  __LINE__, "LogicalErrorException" ).Report

Fires a logical error exception, e.g. throw LOGICAL_ERROR_EXCEPTION("Should never reach this point")

define ACCESS_EXCEPTION#

#define ACCESS_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::AccessException>(__FILE__, __LINE__, "AccessException" ).Report

Fires a access exception, e.g. throw ACCESS_EXCEPTION("Not everybody")

define TIMEOUT_EXCEPTION#

#define TIMEOUT_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::TimeoutException>(__FILE__, __LINE__,"TimeoutException" ).Report

Fires a timeout error exception, e.g. throw TIMEOUT_EXCEPTION("Not everybody")

define DYNAMICCAST_EXCEPTION#

#define DYNAMICCAST_EXCEPTION GENICAM_NAMESPACE::ExceptionReporter<GENICAM_NAMESPACE::DynamicCastException>(__FILE__, __LINE__, "DynamicCastException" ).Report

Fires a dynamic cast exception, e.g. throw DYNAMICCAST_EXCEPTION("Not everybody")

define CHECK_RANGE_I64#

#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));

Range check for int64.

define CHECK_RANGE_FLT#

#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) );

Range check for float.

define CHECK_DYNAMIC_CAST_POINTER#

#define CHECK_DYNAMIC_CAST_POINTER(
    _Pointer
)
assert( (_Pointer) != NULL ); \
        if (NULL == (_Pointer)) throw LOGICAL_ERROR_EXCEPTION( "Unexpected type in dynamic cast" )

Checks if a dynamic_cast is possible.

Source code#

//-----------------------------------------------------------------------------
//  (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>

#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[256];
            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_

Updated on 5 July 2022 at 15:30:01