NodeMapRef.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (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_NODEMAPREF_H
#define GENAPI_NODEMAPREF_H
 
#include <GenICamVersion.h>
#include <Base/GCString.h>
#include <Base/GCException.h>
 
#include <GenApi/Pointer.h>
#include <GenApi/INodeMap.h>
#include <GenApi/IDestroy.h>
#include <GenApi/NodeMapFactory.h>
 
#include <cstdlib>
 
namespace GENAPI_NAMESPACE
{
 
#   ifdef _WIN32
 
    // see below in the Linux branch
    inline IDestroy *CastToIDestroy(INodeMap *pNodeMap)
    {
        return dynamic_cast<IDestroy *>(pNodeMap);
    }
 
#   else
    GENAPI_DECL IDestroy *CastToIDestroy(INodeMap *pNodeMap);
#   endif
 
    template<class TCameraParams>
    class CNodeMapRefT : public TCameraParams
    {
    public:
        CNodeMapRefT(const GENICAM_NAMESPACE::gcstring &DeviceName = "Device");
 
        CNodeMapRefT(INodeMap* pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName = "Device");
 
        CNodeMapRefT(const CNodeMapRefT& Them);
 
        CNodeMapRefT& operator=(const CNodeMapRefT& Them);
 
        CNodeMapRefT& operator=(INodeMap* pNodeMap);
 
        virtual ~CNodeMapRefT();
 
        void _Destroy();
 
        void _LoadXMLFromFile(const GENICAM_NAMESPACE::gcstring &FileName);
 
        void _LoadXMLFromZIPFile(const GENICAM_NAMESPACE::gcstring &ZipFileName);
 
        void _LoadXMLFromZIPData(const void* zipData, size_t zipSize);
 
        void _LoadXMLFromFileInject(const GENICAM_NAMESPACE::gcstring &TargetFileName, const GENICAM_NAMESPACE::gcstring &InjectFileName);
 
        void _LoadXMLFromString(const GENICAM_NAMESPACE::gcstring& XMLData);
 
        void _LoadXMLFromStringInject(const GENICAM_NAMESPACE::gcstring& TargetXMLDataconst, const GENICAM_NAMESPACE::gcstring& InjectXMLData);
 
 
        virtual void _GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const;
 
        virtual GENICAM_NAMESPACE::gcstring _GetDeviceName() const;
 
        virtual void _Poll(int64_t ElapsedTime);
 
        static bool _ClearXMLCache();
 
        //----------------------------------------------------------------
        // INodeMap
        //----------------------------------------------------------------
 
        virtual void _GetNodes(NodeList_t &Nodes) const;
 
        virtual INode* _GetNode(const GENICAM_NAMESPACE::gcstring& key) const;
 
        virtual void _SetSuppressCallbackMode(ECallbackSuppressMode) const;
 
        virtual CNodeWriteConcatenator *_NewNodeWriteConcatenator() const;
 
        virtual bool _ConcatenatedWrite(CNodeWriteConcatenator*, bool featureStreaming = true, GENICAM_NAMESPACE::gcstring_vector* pErrorList = NULL);
 
        virtual void _InvalidateNodes() const;
 
        virtual bool _Connect(IPort* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const;
 
        virtual bool _Connect(IPort* pPort) const;
 
        virtual bool _ParseSwissKnifes( GENICAM_NAMESPACE::gcstring_vector *pErrorList = NULL ) const;
        virtual bool _Connect(IPortStacked* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const;
 
        virtual bool _Connect(IPortStacked* pPort) const;
 
        INodeMap *_Ptr;
 
    private:
        GENICAM_NAMESPACE::gcstring _DeviceName;
        
        //ATTENTION: not thread safe
        int* _pRefCount;
        void Release();
        void Attach(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName, int* pRefCount);
    };
 
 
 
    template<class TCameraParams>
    inline CNodeMapRefT<TCameraParams>::CNodeMapRefT(const GENICAM_NAMESPACE::gcstring &DeviceName)
        : _Ptr(NULL)
        , _DeviceName(DeviceName)
        , _pRefCount(NULL)
    {
    }
    
    template<class TCameraParams>
    inline CNodeMapRefT<TCameraParams>::CNodeMapRefT(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName)
        : _Ptr(NULL)
        , _DeviceName(DeviceName)
        , _pRefCount(NULL)
    {
        assert(pNodeMap);
        Attach(pNodeMap, DeviceName, pNodeMap ? new int(0) : NULL);
    }
    
    template<class TCameraParams>
    GENAPI_NAMESPACE::CNodeMapRefT<TCameraParams>::CNodeMapRefT(const CNodeMapRefT& Them)
        : TCameraParams()
        , _Ptr(NULL)
        , _DeviceName()
        , _pRefCount(NULL)
    {
        Attach(Them._Ptr, Them._DeviceName, Them._pRefCount);
    }
 
    //ATTENTION: not thread safe
    template<class TCameraParams>
    void GENAPI_NAMESPACE::CNodeMapRefT<TCameraParams>::Attach(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName, int* pRefCount)
    {
        // Must be empty
        assert(_Ptr == NULL);
        assert(_pRefCount == NULL);
 
        //always copy device name
        if (&_DeviceName != &DeviceName) //if not assigning member itself
        {
            _DeviceName = DeviceName;
        }
 
        // Attach
        if (pNodeMap)
        {
            assert(pRefCount);
            if (pRefCount)
            {
                ++*pRefCount;
 
                //assign new node map data
                _Ptr = pNodeMap;
                _pRefCount = pRefCount;
 
                // Initialize the references
                TCameraParams::_Initialize(_Ptr);
            }
        }
    }
    
    //ATTENTION: not thread safe
    template<class TCameraParams>
    void GENAPI_NAMESPACE::CNodeMapRefT<TCameraParams>::Release()
    {
        if (_Ptr)
        {
            // Copy node map data for eventual later destruction
            INodeMap* pToDel = _Ptr;
            int* pRefCount = _pRefCount;
 
            // Clear
            _pRefCount = NULL;
            _Ptr = NULL;
            _DeviceName = "Device";
 
            assert(pRefCount);
            // Check if destruction is required
            if (pRefCount)
            {
                assert(*pRefCount > 0);
                --*pRefCount;
                if (*pRefCount == 0)
                {
                    // We do not need this anymore, all references are gone
                    delete pRefCount;
                    pRefCount = NULL;
 
                    // Destroy the node map finally
                    GENAPI_NAMESPACE::IDestroy *pDestroy = CastToIDestroy(pToDel);
                    assert(pDestroy);
                    pDestroy->Destroy(); //must not throw
                }
            }
        }
        else
        {
            // Must not have a refcount when no node map is there.
            assert(_pRefCount == NULL);
        }
    }
 
    template<class TCameraParams>
    CNodeMapRefT<TCameraParams>& GENAPI_NAMESPACE::CNodeMapRefT<TCameraParams>::operator=(INodeMap* pNodeMap)
    {
        Release();
        assert(pNodeMap);
        if (pNodeMap)
        {
            Attach(pNodeMap, pNodeMap->GetDeviceName(), new int(0));
        }
 
        return *this;
    }
 
    template<class TCameraParams>
    CNodeMapRefT<TCameraParams>& GENAPI_NAMESPACE::CNodeMapRefT<TCameraParams>::operator=(const CNodeMapRefT& Them)
    {
        Release();
        Attach(Them._Ptr, Them._DeviceName, Them._pRefCount);
        return *this;
    }
 
    template<class TCameraParams>
    inline CNodeMapRefT<TCameraParams>::~CNodeMapRefT()
    {
        Release();
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_Destroy()
    {
        Release();
    }
 
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromFile(const GENICAM_NAMESPACE::gcstring &FileName)
    {
        // FileName environment is replaced in CNodeMapFactory ctor
 
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_Xml, FileName);
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap( _DeviceName );
        Attach( pNodeMap, _DeviceName, new int( 0 ) );
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromZIPFile(const GENICAM_NAMESPACE::gcstring &ZipFileName)
    {
        // FileName environment is replaced in CNodeMapFactory ctor
 
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_ZippedXml, ZipFileName);
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
        Attach( pNodeMap, _DeviceName, new int(0));
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromFileInject(const GENICAM_NAMESPACE::gcstring &TargetFileName, const GENICAM_NAMESPACE::gcstring &InjectFileName)
    {
        // xxxFileName environment is replaced in CNodeMapFactory ctor
 
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_Xml, TargetFileName);
        CNodeMapFactory injectNodeMapData(ContentType_Xml, InjectFileName);
        nodeMapData.AddInjectionData(injectNodeMapData);
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap(_DeviceName);
        Attach( pNodeMap, _DeviceName, new int( 0 ) );
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromString(const GENICAM_NAMESPACE::gcstring& XMLData)
    {
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_Xml, XMLData.c_str(), XMLData.size()); //avoid string copy
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap(_DeviceName);
        Attach( pNodeMap, _DeviceName, new int( 0 ) );
    }
 
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromZIPData(const void* zipData, size_t zipSize)
    {
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_ZippedXml, zipData, zipSize);
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
        Attach( pNodeMap, _DeviceName, new int( 0 ) );
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromStringInject(const GENICAM_NAMESPACE::gcstring& TargetXMLData, const GENICAM_NAMESPACE::gcstring& InjectXMLData)
    {
        // Load the DLL
        if(_Ptr)
            throw RUNTIME_EXCEPTION("Node map already created");
 
        // Load the XML file
        CNodeMapFactory nodeMapData(ContentType_Xml, TargetXMLData.c_str(), TargetXMLData.size()); //avoid string copy
        CNodeMapFactory injectNodeMapData(ContentType_Xml, InjectXMLData.c_str(), InjectXMLData.size()); //avoid string copy
        nodeMapData.AddInjectionData(injectNodeMapData);
 
        // First create node map then the reference counter. This prevents a leak in case of bad node map
        INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
        Attach( pNodeMap, _DeviceName, new int( 0 ) );
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const
    {
        CNodeMapFactory().GetSupportedSchemaVersions(SchemaVersions);
    }
 
    template<class TCameraParams>
    inline GENICAM_NAMESPACE::gcstring CNodeMapRefT<TCameraParams>::_GetDeviceName() const
    {
        if(_Ptr)
            return _Ptr->GetDeviceName();
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_Poll(int64_t ElapsedTime)
    {
        if(_Ptr)
            return _Ptr->Poll(ElapsedTime);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_GetNodes(NodeList_t &Nodes) const
    {
        if(_Ptr)
            return _Ptr->GetNodes(Nodes);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_SetSuppressCallbackMode(ECallbackSuppressMode mode) const
    {
        if (_Ptr)
            return _Ptr->SetSuppressCallbackMode(mode);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
 
    template<class TCameraParams>
    inline CNodeWriteConcatenator  *CNodeMapRefT<TCameraParams>::_NewNodeWriteConcatenator() const
    {
        if (_Ptr)
            return _Ptr->NewNodeWriteConcatenator();
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_ConcatenatedWrite(CNodeWriteConcatenator* pConcatenatedWrite, bool featureStreaming, GENICAM_NAMESPACE::gcstring_vector* pErrorList)
    {
        if (_Ptr)
            return _Ptr->ConcatenatedWrite(pConcatenatedWrite, featureStreaming, pErrorList);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline INode* CNodeMapRefT<TCameraParams>::_GetNode(const GENICAM_NAMESPACE::gcstring& key) const
    {
        if(_Ptr)
            return _Ptr->GetNode(key);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline void CNodeMapRefT<TCameraParams>::_InvalidateNodes() const
    {
        if(_Ptr)
            return _Ptr->InvalidateNodes();
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_ParseSwissKnifes( GENICAM_NAMESPACE::gcstring_vector *pErrorList ) const
    {
        if (_Ptr)
            return _Ptr->ParseSwissKnifes(pErrorList);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_Connect(IPort* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const
    {
        if(_Ptr)
            return _Ptr->Connect(pPort, PortName);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_Connect(IPort* pPort) const
    {
        if(_Ptr)
            return _Ptr->Connect(pPort);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_Connect(IPortStacked* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const
    {
        if (_Ptr)
            return _Ptr->Connect(pPort, PortName);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_Connect(IPortStacked* pPort) const
    {
        if (_Ptr)
            return _Ptr->Connect(pPort);
        throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
    }
 
    template<class TCameraParams>
    inline bool CNodeMapRefT<TCameraParams>::_ClearXMLCache()
    {
        return CNodeMapFactory::ClearCache();
    }
 
    class CGeneric_XMLLoaderParams
    {
    protected:
        virtual void _Initialize(GENAPI_NAMESPACE::INodeMap*) {}
        virtual ~CGeneric_XMLLoaderParams()
        {
            // ensure to release all ressources
        }
    };
 
 
    class CNodeMapRef : public CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>
    {
    public:
        CNodeMapRef(const GENICAM_NAMESPACE::gcstring &DeviceName = "Device")
            : CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>(DeviceName)
        {
        }
 
        CNodeMapRef(INodeMap* pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName = "Device")
            : CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>(pNodeMap, DeviceName)
        {
        }
 
        CNodeMapRef(const CNodeMapRef& Them)
            : CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>(Them)
        {
        }
 
        CNodeMapRef& operator=(const CNodeMapRef& Them)
        {
            CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>::operator=(Them);
            return *this;
        }
 
        CNodeMapRef& operator=(INodeMap* pNodeMap)
        {
            CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>::operator=(pNodeMap);
            return *this;
        }
    };
 
}
 
#endif // ifndef GENAPI_NODEMAPPTR_H