Skip to content

GenApi/Pointer.h#

Definition of template CPointer.

Namespaces#

Name
GenApi
Contains definitions of the types of GenICam GenApi modules.

Classes#

Name
class GenApi::CPointer
Encapsulates a GenApi pointer dealing with the dynamic_cast automatically.
class GenApi::CFloatPtr
SmartPointer for IFloat interface pointer.

Source code#

//-----------------------------------------------------------------------------
//  (c) 2006 by Basler Vision Technologies
//  Section: Vision Components
//  Project: GenApi
//  Author:  Fritz Dierks
//  $Header$
//
//  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 GENAPI_POINTER_H
#define GENAPI_POINTER_H

#include <assert.h>
#include <GenICamFwd.h>
#include <GenApi/IEnumeration.h>
#include <GenApi/IFloat.h>
#include <GenApi/IInteger.h>

namespace GENAPI_NAMESPACE
{
    //*************************************************************
    // CPointer class
    //*************************************************************

    template <class T, class B = IBase>
    class CPointer
    {

    public:
        CPointer(void) throw()
            : m_pT( NULL )
        {
        }

        CPointer( B *pB )
            : m_pT( dynamic_cast<T*>(pB) )
        {
        }

        virtual ~CPointer(void)
        {
        }

        void operator=( B *pB )
        {
            m_pT = dynamic_cast<T*>(pB);
        }

        operator T*(void) const
        {
            if (NULL == m_pT)
                throw LOGICAL_ERROR_EXCEPTION( "NULL pointer dereferenced" );
            return m_pT;
        }

        T& operator*(void) const
        {
            if (NULL == m_pT)
                throw LOGICAL_ERROR_EXCEPTION( "NULL pointer dereferenced" );
            return *m_pT;
        }

        T& operator()(void) const
        {
            if (NULL == m_pT)
                throw LOGICAL_ERROR_EXCEPTION( "NULL pointer dereferenced" );
            return *m_pT;
        }

        T* operator->(void) const
        {
            if (NULL == m_pT)
                throw LOGICAL_ERROR_EXCEPTION( "NULL pointer dereferenced" );
            return m_pT;
        }

        bool IsValid() const throw()
        {
            return m_pT != NULL;
        }

        operator bool(void) const throw()
        {
            return m_pT != NULL;
        }

        bool operator==(T* pT) const 
        {
            return m_pT == pT;
        }

        bool operator==(const CPointer<T,B> &rT) const 
        {
            return m_pT == rT.m_pT;
        }

        bool operator==(int nMustBeNull) const
        {
            if (0 != nMustBeNull)
                throw LOGICAL_ERROR_EXCEPTION( "argument must be NULL" );
            return NULL == m_pT;
        }


    protected:

        T* m_pT;
    };

    //*************************************************************
    // Smartpointer for all interface
    //*************************************************************


    typedef CPointer<IBase> CBasePtr;

    typedef CPointer<INode> CNodePtr;

    typedef CPointer<IValue> CValuePtr;

    typedef CPointer<ICategory> CCategoryPtr;

    typedef CPointer<IBoolean> CBooleanPtr;

    typedef CPointer<IInteger> CIntegerPtr;

    typedef CPointer<IString> CStringPtr;

    typedef CPointer<IRegister> CRegisterPtr;

    typedef CPointer<IEnumeration> CEnumerationPtr;

    typedef CPointer<IEnumEntry> CEnumEntryPtr;

    typedef CPointer<IPort> CPortPtr;

    typedef CPointer<IPortReplay> CPortReplayPtr;

    typedef CPointer<IPortRecorder> CPortRecorderPtr;

    typedef CPointer<IPortWriteList, IPortWriteList> CPortWriteListPtr;

    typedef CPointer<IChunkPort> CChunkPortPtr;

    typedef CPointer<INodeMap, INodeMap> CNodeMapPtr;

    typedef CPointer<IDeviceInfo, INodeMap> CDeviceInfoPtr;

    typedef CPointer<IUserData, INodeMap> CNodeMapUserDataPtr;
    typedef CPointer<IUserData> CNodeUserDataPtr;

    typedef CPointer<ISelector> CSelectorPtr;

     typedef CPointer<ICommand> CCommandPtr;

    class CFloatPtr : public CPointer<IFloat, IBase>
    {
    public:
        CFloatPtr() throw()
            : CPointer<IFloat, IBase>(  )
        {
        }

        CFloatPtr( IBase *pB )
            : CPointer<IFloat, IBase>( pB )
        {
        }

        void operator=( IBase *pB )
        {
            CPointer<IFloat, IBase>::operator =(pB);
        }

        IInteger *GetIntAlias()
        {
            return dynamic_cast<IInteger*>(m_pT->GetNode()->GetCastAlias());
        }

        IEnumeration *GetEnumAlias()
        {
            return dynamic_cast<IEnumeration*>(m_pT->GetNode()->GetCastAlias());
        }
    };



    typedef CPointer<IPortConstruct> CPortConstructPtr;


    inline GENICAM_NAMESPACE::gcstring GetInterfaceName(IBase *pBase)
    {
#       ifdef _MSC_VER
#           pragma warning (push) // icc -W4 complains: controlling expression is constant
#           pragma warning (disable : 279)
#       endif
        assert(pBase && "don't call this with a NULL pointer");
#       ifdef _MSC_VER
#           pragma warning (pop)
#       endif
        CNodePtr ptrNode(pBase);
        switch(ptrNode->GetPrincipalInterfaceType())
        {
        case intfIValue:
            return GENICAM_NAMESPACE::gcstring("IValue");
        case intfIInteger:
            return GENICAM_NAMESPACE::gcstring("IInteger");
        case intfIBoolean:
            return GENICAM_NAMESPACE::gcstring("IBoolean");
        case intfICommand:
            return GENICAM_NAMESPACE::gcstring("ICommand");
        case intfIFloat:
            return GENICAM_NAMESPACE::gcstring("IFloat");
        case intfIString:
            return GENICAM_NAMESPACE::gcstring("IString");
        case intfIRegister:
            return GENICAM_NAMESPACE::gcstring("IRegister");
        case intfICategory:
            return GENICAM_NAMESPACE::gcstring("ICategory");
        case intfIEnumeration:
            return GENICAM_NAMESPACE::gcstring("IEnumeration");
        case intfIEnumEntry:
            return GENICAM_NAMESPACE::gcstring("IEnumEntry");
        case intfIPort:
            return GENICAM_NAMESPACE::gcstring("IPort");
// Do not use this pragma in public header files (warnings in depend projects): #pragma BullseyeCoverage off
        case intfIBase:
        default:
            return GENICAM_NAMESPACE::gcstring("IBase");
// Do not use this pragma in public header files (warnings in depend projects): #pragma BullseyeCoverage on
        }
    }

    template <class T, class B>
    inline bool IsReadable( const CPointer<T, B>& ptr)
    {
        return ptr.IsValid() && IsReadable( ptr->GetAccessMode() );
    }

    template <class T, class B>
    inline bool IsWritable( const CPointer<T, B>& ptr)
    {
        return ptr.IsValid() && IsWritable( ptr->GetAccessMode() );
    }

    template <class T, class B>
    inline bool IsImplemented( const CPointer<T, B>& ptr)
    {
        return ptr.IsValid() && IsImplemented( ptr->GetAccessMode() );
    }

    template <class T, class B>
    inline bool IsAvailable( const CPointer<T, B>& ptr)
    {
        return ptr.IsValid() && IsAvailable( ptr->GetAccessMode() );
    }




}

#endif // ifndef GENAPI_POINTER_H

Updated on 5 July 2022 at 15:30:01