GCException.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (c) 2004 by Basler Vision Technologies
//  Author:  Fritz Dierks
//
//  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.
// 
//  Contributions
//             changed minor things like namespace
//             added a AccessException
//             added a TimeoutException
//  Copyright (c) 2005 STEMMER IMAGING (Rupert Stelz) 
//
//             used _vsnprintf_s function for VS8 and higher (compiler fork)
//  Copyright (c) 2006 STEMMER IMAGING (Sascha Dorenbeck)
//
//             prepared for remove of std::exception base class 
//  Copyright (c) 2014 STEMMER IMAGING (Sascha Dorenbeck)
//
//-----------------------------------------------------------------------------
#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_