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