Node.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (c) 2006-2009 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_NODE_H
#define GENAPI_NODE_H

#include <string>
#include <sstream>
#include <algorithm>
#include <cctype>
#include "Base/GCException.h"
#include "../GenApiDll.h"
#include "../Synch.h"
#include "../Types.h"
#include "../INode.h"
#include "../ICategory.h"
#include "INodePrivate.h"
#include "INodeMapPrivate.h"
#include "../IInteger.h"
#include "../IBoolean.h"
#include "../ISelector.h"
#include "../NodeCallback.h"
#include "../EnumClasses.h"
#include "Log.h"
#include "Value2String.h"
#include "PolyReference.h"
#include "NodeMapData/NodeMapDataTypes.h"
#include "NodeMapData/NodeData.h"
//#include "NodeMap.h"
#include "../IUserData.h"
#include <list>

class CProperty;
class CNodeDataMap;
class CNodeMap;

namespace GENAPI_NAMESPACE
{
    namespace detail
    {
        template< typename C, typename V>
        void push_back_unique(C &c, const V &v)
        {
            if (std::find(c.begin(), c.end(), v) == c.end())
            {
                c.push_back(v);
            }
        }
    }

    //*************************************************************
    // CNodeImpl class
    //*************************************************************

    class CNodeImpl : public INodePrivate, public ISelector, public IUserData
    {
    public:
        //-------------------------------------------------------------

            CNodeImpl();

            virtual ~CNodeImpl();

    protected:
        //-------------------------------------------------------------

            virtual EAccessMode InternalGetAccessMode() const;

            #pragma BullseyeCoverage off
            virtual EInterfaceType InternalGetPrincipalInterfaceType() const
            {
                return intfIBase;
            }
            #pragma BullseyeCoverage on

            EAccessMode InternalGetAccessMode(IBase* pValue) const;

    protected:
        //-------------------------------------------------------------

            virtual GENICAM_NAMESPACE::gcstring InternalGetName(bool FullQualified=false) const;

            virtual GENAPI_NAMESPACE::ENameSpace InternalGetNameSpace()const;

            virtual EVisibility InternalGetVisibility() const;

            // Invalidate the node
            virtual void InternalInvalidateNode( std::list<CNodeCallback*> &CallbacksToFire );

            virtual bool InternalIsCachable() const;

            virtual ECachingMode InternalGetCachingMode() const;

            virtual int64_t InternalGetPollingTime() const;

            virtual GENICAM_NAMESPACE::gcstring InternalGetToolTip() const;

            virtual GENICAM_NAMESPACE::gcstring InternalGetDescription() const;

            // Get node display name
            virtual GENICAM_NAMESPACE::gcstring InternalGetDisplayName() const;

            virtual GENICAM_NAMESPACE::gcstring InternalGetDeviceName() const;

            virtual void InternalGetChildren(GENAPI_NAMESPACE::NodeList_t &Children, ELinkType LinkType) const;


            virtual CallbackHandleType InternalRegisterCallback( CNodeCallback *pCallback );


            virtual bool InternalDeregisterCallback( CallbackHandleType hCallback );

            virtual INodeMap* InternalGetNodeMap() const;

            virtual GENICAM_NAMESPACE::gcstring GetEventID() const;

            virtual bool IsStreamable() const;

            virtual void GetParents(GENAPI_NAMESPACE::NodeList_t &Parents) const;

            virtual void GetPropertyNames(GENICAM_NAMESPACE::gcstring_vector &PropertyNames) const;


            virtual bool GetProperty(const GENICAM_NAMESPACE::gcstring& PropertyName, GENICAM_NAMESPACE::gcstring& ValueStr, GENICAM_NAMESPACE::gcstring& AttributeStr);

            virtual void ImposeAccessMode(EAccessMode ImposedAccessMode);

            virtual void ImposeVisibility(EVisibility ImposedVisibility);

            virtual INode* GetAlias() const;

            virtual INode* GetCastAlias() const;

            virtual void InternalCheckError() const;

            virtual GENICAM_NAMESPACE::gcstring InternalGetDocuURL() const;

            virtual bool InternalIsDeprecated() const;

            virtual bool IsFeature() const;

            virtual EYesNo InternalIsAccessModeCacheable() const;


            inline bool IsAccessModeCached() const
            {
                if( _UndefinedAccesMode == m_AccessModeCache )
                    return false;
#pragma BullseyeCoverage off
                if( _CycleDetectAccesMode == m_AccessModeCache )
#pragma BullseyeCoverage on
                {
                    // the cycle is neutralized by making at least one node AccessMode cacheable
                    m_AccessModeCache = RW;
                    GCLOGWARN( m_pAccessLog,  "InternalGetAccessMode : ReadCycle detected at = '%s'", m_Name.c_str() );
                }
                return true;
            }

    public:
        //-------------------------------------------------------------

            virtual void Initialize(GENAPI_NAMESPACE::INodeMapPrivate* const pNodeMap, CNodeData::ENodeType_t NodeType, NodeID_t &NodeID );
            virtual CNodeData::ENodeType_t GetNodeType();
            virtual NodeID_t GetNodeID();
            virtual void FinalConstruct();
            virtual void SetProperty( CProperty &Property );
            virtual bool GetProperty(CNodeDataMap *pNodeDataMap, CPropertyID::EProperty_ID_t PropertyID, CNodeData::PropertyVector_t &PropertyList) const;
            virtual void SetInvalid(ESetInvalidMode simMode);           
            virtual void CollectCallbacksToFire(std::list<CNodeCallback*> &CallbacksToFire, bool allDependents = false, bool always = false);
            virtual bool IsTerminalNode() const;
            virtual void GetTerminalNodes( GENAPI_NAMESPACE::NodeList_t& Terminals ) const;
            virtual bool Poll( int64_t ElapsedTime );
            virtual bool CanBeWritten(bool Verify);
            virtual bool CanBeRead(bool Verify);

    public:
        //-------------------------------------------------------------

            virtual bool IsSelector() const;
            virtual void GetSelectedFeatures( FeatureList_t& list ) const;
            virtual void GetSelectingFeatures( FeatureList_t& ) const;

    public:

        inline INodeMapPrivate* GetNodeMapPrivate()
        {
            return m_pNodeMap;
        }

        inline void SetParent( INodePrivate *pParent )
        {
            detail::push_back_unique(m_Parents, pParent);
        }

        // 1 : use macro for speed
        // 0 : used function for debugging
#if 0

# define ADD_ORPHAN_CHILD( PropertyID, Property ) \
        INodePrivate *pNode = dynamic_cast<CNodeMap*>(m_pNodeMap)->_GetNodeByID( Property.NodeID() ); \
        if( CPropertyID::IsInvalidatingPointer(PropertyID) )\
        { \
            detail::push_back_unique(m_InvalidatingChildren, pNode); \
            if( CPropertyID::IsReadingPointer(PropertyID) ) \
            { \
                detail::push_back_unique(m_ReadingChildren, pNode); \
                if( CPropertyID::IsWritingPointer(PropertyID) ) \
                { \
                    detail::push_back_unique(m_WritingChildren, pNode); \
                } \
             } \
         }

        // the compiler will optimize the if() statements away if PropertyID is a constant
# define ADD_CHILD( PropertyID, Property ) \
        INodePrivate *pNode = dynamic_cast<CNodeMap*>(m_pNodeMap)->_GetNodeByID( Property.NodeID() ); \
        if( CPropertyID::IsInvalidatingPointer(PropertyID) )\
        { \
            detail::push_back_unique(m_InvalidatingChildren, pNode);\
            dynamic_cast<CNodeImpl*>(pNode)->SetParent( this );\
            if( CPropertyID::IsReadingPointer(PropertyID) ) \
            { \
                detail::push_back_unique(m_ReadingChildren, pNode);\
                if( CPropertyID::IsWritingPointer(PropertyID) ) \
                { \
                    detail::push_back_unique(m_WritingChildren, pNode); \
                } \
            } \
        }

#else
# define ADD_ORPHAN_CHILD( PropertyID, Property ) \
        INodePrivate *pNode = dynamic_cast<CNodeMap*>(m_pNodeMap)->_GetNodeByID(Property.NodeID()); \
        add_orphan_child( PropertyID, Property, pNode );

# define ADD_CHILD( PropertyID, Property ) \
        INodePrivate *pNode = dynamic_cast<CNodeMap*>(m_pNodeMap)->_GetNodeByID(Property.NodeID()); \
        add_child( PropertyID, Property, pNode );

    // This is a helper function performing the same tasks as the macro above 
    // In contrast to the macro however you can set breakpoint here :-)
    void add_child(CPropertyID::EProperty_ID_t PropertyID, CProperty &/*Property*/, INodePrivate *pNode)
    {
        if (CPropertyID::IsInvalidatingPointer(PropertyID))
        {
            detail::push_back_unique(m_InvalidatingChildren, pNode);
            dynamic_cast<CNodeImpl*>(pNode)->SetParent(this);  // this is not present in add_orphan_child
            if (CPropertyID::IsReadingPointer(PropertyID))
            {
                detail::push_back_unique(m_ReadingChildren, pNode);
                if (CPropertyID::IsWritingPointer(PropertyID))
                {
                    detail::push_back_unique(m_WritingChildren, pNode);
                }
            }
        }
    }

    void add_orphan_child(CPropertyID::EProperty_ID_t PropertyID, CProperty &/*Property*/, INodePrivate *pNode)
    {
        if (CPropertyID::IsInvalidatingPointer(PropertyID))
        {
            detail::push_back_unique(m_InvalidatingChildren, pNode);
            if (CPropertyID::IsReadingPointer(PropertyID))
            {
                detail::push_back_unique(m_ReadingChildren, pNode);
                if (CPropertyID::IsWritingPointer(PropertyID))
                {
                    detail::push_back_unique(m_WritingChildren, pNode);
                }
            }
        }
    }
#endif
    private:
        //-------------------------------------------------------------
        // ! \name Interface IUserData
            UserData_t GetUserData() const;
            UserData_t SetUserData( UserData_t userdata );
    protected:
        //-------------------------------------------------------------

            GENICAM_NAMESPACE::gcstring GetNodeType() const {
                       std::string nodetype;
                       Value2String(m_NodeTypeEnum, nodetype);
                       
                       return nodetype.c_str();
            }

            GENICAM_NAMESPACE::gcstring m_Name;

            GENICAM_NAMESPACE::gcstring m_Extension;

            ENameSpace m_NameSpace;

            GENICAM_NAMESPACE::gcstring m_DeviceName;

            GENICAM_NAMESPACE::gcstring m_DisplayName;

            GENICAM_NAMESPACE::gcstring m_ToolTip;

            GENICAM_NAMESPACE::gcstring m_Description;

            EVisibility m_Visibility;

            CBooleanPolyRef m_IsImplemented;

            CBooleanPolyRef m_IsAvailable;

            CBooleanPolyRef m_IsLocked;

            CBooleanPolyRef m_BlockPolling;

            IEnumeration *m_pError;

            INode *m_pAlias;

            INode *m_pCastAlias;

            mutable ECachingMode m_CachingMode;

            FeatureList_t m_Selected;

            FeatureList_t m_Selecting;

            GENICAM_NAMESPACE::gcstring m_EventID;

            EYesNo m_IsStreamable;

            EAccessMode m_ImposedAccessMode;

            EVisibility m_ImposedVisibility;

            int64_t m_PollingTime;

            enum ETerminalPropagationState
            {
                eNotVisited, 
                eBeingVisited, 
                eTerminalPropagationDone 
            };

            ETerminalPropagationState m_propagationState;

            NodeList_t m_Invalidators;

            GENICAM_NAMESPACE::gcstring m_DocuURL;

            EYesNo m_IsDeprecated;

            GENICAM_NAMESPACE::gcstring_vector m_PropertyNames;

            EYesNo m_IsFeature;


    protected:
        //-------------------------------------------------------------

            NodePrivateVector_t m_Parents;

            NodePrivateVector_t m_ReadingChildren;

            NodePrivateVector_t m_WritingChildren;

            NodePrivateVector_t m_InvalidatingChildren;

            NodePrivateVector_t m_AllDependingNodes;

            NodePrivateVector_t m_AllTerminalNodes;

            NodePrivateVector_t m_VariableChildren;

    protected:
        //-------------------------------------------------------------

            mutable ECachingMode m_CachingModeCache;

            mutable EAccessMode m_AccessModeCache;

            inline void CacheAccessModeIfPossible( EAccessMode AccessMode ) const
            {
                m_AccessModeCache = ( Yes == InternalIsAccessModeCacheable() ) ? AccessMode : _UndefinedAccesMode;
            }

            mutable bool m_ValueCacheValid;

            mutable bool m_ListOfValidValuesCacheValid;

            virtual bool InternalIsValueCacheValid() const;

            mutable EYesNo m_AccessModeCacheability;


    protected:
        //-------------------------------------------------------------

            INodeMapPrivate* m_pNodeMap;

            int64_t m_ElapsedTime;

            typedef AutoLock Lock;

            CLock& GetLock() const;

            Counter& GetBathometer() const;

            void PreSetValue();

            void PostSetValue( std::list<CNodeCallback*> &CallbacksToFire );

            bool m_DontDeleteThisCache;

            bool m_TerminalNodeWritten;

            class PostSetValueFinalizer
            {
            public:
                PostSetValueFinalizer(CNodeImpl* pThis,  std::list<CNodeCallback*> &CallbacksToFire ) :
                    m_pThis( pThis ),
                    m_CallbacksToFire( CallbacksToFire )
                {}

                ~PostSetValueFinalizer()
                {
                    m_pThis->PostSetValue( m_CallbacksToFire );
                }

                CNodeImpl* m_pThis;

                std::list<CNodeCallback*> &m_CallbacksToFire;

            private:
                // \{
                PostSetValueFinalizer(const PostSetValueFinalizer&);
                PostSetValueFinalizer& operator=(const PostSetValueFinalizer&);
                // \}
            };

            std::list<CNodeCallback*> m_Callbacks;

            class EntryMethodFinalizer
            {
            public:
                EntryMethodFinalizer(const INodePrivate* pThis, EMethod EntryMethod, bool stremable = false, bool IgnoreCache = false)
                {
                    assert(pThis);
                    m_pNodeMapPrivate = dynamic_cast<INodeMapPrivate*>( pThis->GetNodeMap() );
                    m_pNodeMapPrivate->SetEntryPoint(EntryMethod, pThis, stremable, IgnoreCache);
                }

                ~EntryMethodFinalizer()
                {
                    m_pNodeMapPrivate->ResetEntryPoint();
                }

            private:
                INodeMapPrivate *m_pNodeMapPrivate;
            };

            GENICAM_NAMESPACE::gcstring GetQualifiedName(GENICAM_NAMESPACE::gcstring Name, ENameSpace NameSpace) const;


        //-------------------------------------------------------------

            // for safety reasons please keep these member variables at the
            // end of the class' memory layout

            GENICAM_NAMESPACE::ILogger *m_pAccessLog;

            GENICAM_NAMESPACE::ILogger *m_pValueLog;

            GENICAM_NAMESPACE::ILogger *m_pRangeLog;

            GENICAM_NAMESPACE::ILogger *m_pPortLog;

            GENICAM_NAMESPACE::ILogger *m_pCacheLog;

            GENICAM_NAMESPACE::ILogger *m_pPreProcLog;

            GENICAM_NAMESPACE::ILogger *m_pMiscLog;



        NodeID_t m_NodeID;

        CNodeData::ENodeType_t m_NodeTypeEnum;

        EYesNo m_ExposeStatic;
        
        UserData_t m_pUserData;

    private:
#if defined( _WIN32 ) && !defined( PHARLAP_WIN32 )
        typedef std::wstring string_t;
        typedef std::wstring::size_type size_type;
        typedef std::wostringstream ostringstream_t;
        typedef wchar_t char_t;
        #define QUALIFY_LITERAL( x ) _L( x )
        #define _L( x ) L ## x
        #define GET_MODULE_FILE_NAME GetModuleFileNameW
        #define GET_CSTR( x ) x.w_str().c_str()
        #define GET_LOCALE_INFO GetLocaleInfoW
#else
        typedef std::string string_t;
        typedef std::string::size_type size_type;
        typedef std::ostringstream ostringstream_t;
        typedef char char_t;
        #define QUALIFY_LITERAL( x ) x
        #define GET_MODULE_FILE_NAME GetModuleFileName
        #define GET_CSTR( x ) x.c_str()
        #define GET_LOCALE_INFO GetLocaleInfo
#endif

        static const size_t MaxPath;
        void GetNodeName( string_t& VariableContent ) const;
        void GetStringStreamContent( const ostringstream_t& Content, string_t& VariableContent ) const;
        void GetVendorName( string_t& VariableContent ) const;
        void GetModelName( string_t& VariableContent ) const;
        void GetStandardNameSpace( string_t& VariableContent ) const;
        void GetNodeValue( const CValuePtr& ptrValue, CNodeImpl::string_t& VariableContent ) const;

    };

    bool DeleteDoubleCallbacksCompare (GENAPI_NAMESPACE::CNodeCallback* pA, GENAPI_NAMESPACE::CNodeCallback* pB);

    void DeleteDoubleCallbacks( std::list<CNodeCallback*> &CallbackList );

}

#endif // ifndef GENAPI_NODE_H