All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
NodeMapRef.h
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // (c) 2006 by Basler Vision Technologies
3 // Section: Vision Components
4 // Project: GenApi
5 // Author: Fritz Dierks
6 // $Header$
7 //
8 // License: This file is published under the license of the EMVA GenICam Standard Group.
9 // A text file describing the legal terms is included in your installation as 'GenICam_license.pdf'.
10 // If for some reason you are missing this file please contact the EMVA or visit the website
11 // (http://www.genicam.org) for a full copy.
12 //
13 // THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
14 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD GROUP
17 // OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
20 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
21 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
23 // POSSIBILITY OF SUCH DAMAGE.
24 //-----------------------------------------------------------------------------
31 #ifndef GENAPI_NODEMAPREF_H
32 #define GENAPI_NODEMAPREF_H
33 
34 #include <GenICamVersion.h>
35 #include <Base/GCString.h>
36 #include <Base/GCException.h>
37 
38 #include <GenApi/Pointer.h>
39 #include <GenApi/INodeMap.h>
40 #include <GenApi/IDestroy.h>
41 #include <GenApi/NodeMapFactory.h>
42 
43 #include <cstdlib>
44 
45 namespace GENAPI_NAMESPACE
46 {
47 
48 # ifdef _WIN32
49 
50  // see below in the Linux branch
51  inline IDestroy *CastToIDestroy(INodeMap *pNodeMap)
52  {
53  return dynamic_cast<IDestroy *>(pNodeMap);
54  }
55 
56 # else
59 # endif
60 
66  template<class TCameraParams>
67  class CNodeMapRefT : public TCameraParams
68  {
69  public:
71  CNodeMapRefT(const GENICAM_NAMESPACE::gcstring &DeviceName = "Device");
72 
74  CNodeMapRefT(INodeMap* pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName = "Device");
75 
77  CNodeMapRefT(const CNodeMapRefT& Them);
78 
80  CNodeMapRefT& operator=(const CNodeMapRefT& Them);
81 
83  CNodeMapRefT& operator=(INodeMap* pNodeMap);
84 
86  virtual ~CNodeMapRefT();
87 
89  void _Destroy();
90 
92  void _LoadXMLFromFile(const GENICAM_NAMESPACE::gcstring &FileName);
93 
95  void _LoadXMLFromZIPFile(const GENICAM_NAMESPACE::gcstring &ZipFileName);
96 
98  void _LoadXMLFromZIPData(const void* zipData, size_t zipSize);
99 
101  void _LoadXMLFromFileInject(const GENICAM_NAMESPACE::gcstring &TargetFileName, const GENICAM_NAMESPACE::gcstring &InjectFileName);
102 
104  void _LoadXMLFromString(const GENICAM_NAMESPACE::gcstring& XMLData);
105 
107  void _LoadXMLFromStringInject(const GENICAM_NAMESPACE::gcstring& TargetXMLDataconst, const GENICAM_NAMESPACE::gcstring& InjectXMLData);
108 
110 
114  virtual void _GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const;
115 
118 
120  virtual void _Poll(int64_t ElapsedTime);
121 
123  static bool _ClearXMLCache();
124 
125  //----------------------------------------------------------------
126  // INodeMap
127  //----------------------------------------------------------------
128 
130  virtual void _GetNodes(NodeList_t &Nodes) const;
131 
133  virtual INode* _GetNode(const GENICAM_NAMESPACE::gcstring& key) const;
134 
137 
140 
142  virtual bool _ConcatenatedWrite(CNodeWriteConcatenator*, bool featureStreaming = true, GENICAM_NAMESPACE::gcstring_vector* pErrorList = NULL);
143 
145  virtual void _InvalidateNodes() const;
146 
148  virtual bool _Connect(IPort* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const;
149 
151  virtual bool _Connect(IPort* pPort) const;
152 
154  virtual bool _ParseSwissKnifes( GENICAM_NAMESPACE::gcstring_vector *pErrorList = NULL ) const;
156  virtual bool _Connect(IPortStacked* pPort, const GENICAM_NAMESPACE::gcstring& PortName) const;
157 
159  virtual bool _Connect(IPortStacked* pPort) const;
160 
163 
164  private:
167 
168  //ATTENTION: not thread safe
170  void Release();
171  void Attach(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName, int* pRefCount);
172  };
173 
174 
175 
176  template<class TCameraParams>
178  : _Ptr(NULL)
179  , _DeviceName(DeviceName)
180  , _pRefCount(NULL)
181  {
182  }
183 
184  template<class TCameraParams>
186  : _Ptr(NULL)
187  , _DeviceName(DeviceName)
188  , _pRefCount(NULL)
189  {
190  assert(pNodeMap);
191  Attach(pNodeMap, DeviceName, pNodeMap ? new int(0) : NULL);
192  }
193 
194  template<class TCameraParams>
196  : TCameraParams()
197  , _Ptr(NULL)
198  , _DeviceName()
199  , _pRefCount(NULL)
200  {
201  Attach(Them._Ptr, Them._DeviceName, Them._pRefCount);
202  }
203 
204  //ATTENTION: not thread safe
205  template<class TCameraParams>
207  {
208  // Must be empty
209  assert(_Ptr == NULL);
210  assert(_pRefCount == NULL);
211 
212  //always copy device name
213  if (&_DeviceName != &DeviceName) //if not assigning member itself
214  {
215  _DeviceName = DeviceName;
216  }
217 
218  // Attach
219  if (pNodeMap)
220  {
221  assert(pRefCount);
222  if (pRefCount)
223  {
224  ++*pRefCount;
225 
226  //assign new node map data
227  _Ptr = pNodeMap;
228  _pRefCount = pRefCount;
229 
230  // Initialize the references
231  TCameraParams::_Initialize(_Ptr);
232  }
233  }
234  }
235 
236  //ATTENTION: not thread safe
237  template<class TCameraParams>
239  {
240  if (_Ptr)
241  {
242  // Copy node map data for eventual later destruction
243  INodeMap* pToDel = _Ptr;
244  int* pRefCount = _pRefCount;
245 
246  // Clear
247  _pRefCount = NULL;
248  _Ptr = NULL;
249  _DeviceName = "Device";
250 
251  assert(pRefCount);
252  // Check if destruction is required
253  if (pRefCount)
254  {
255  assert(*pRefCount > 0);
256  --*pRefCount;
257  if (*pRefCount == 0)
258  {
259  // We do not need this anymore, all references are gone
260  delete pRefCount;
261  pRefCount = NULL;
262 
263  // Destroy the node map finally
264  GENAPI_NAMESPACE::IDestroy *pDestroy = CastToIDestroy(pToDel);
265  assert(pDestroy);
266  pDestroy->Destroy(); //must not throw
267  }
268  }
269  }
270  else
271  {
272  // Must not have a refcount when no node map is there.
273  assert(_pRefCount == NULL);
274  }
275  }
276 
277  template<class TCameraParams>
279  {
280  Release();
281  assert(pNodeMap);
282  if (pNodeMap)
283  {
284  Attach(pNodeMap, pNodeMap->GetDeviceName(), new int(0));
285  }
286 
287  return *this;
288  }
289 
290  template<class TCameraParams>
292  {
293  Release();
294  Attach(Them._Ptr, Them._DeviceName, Them._pRefCount);
295  return *this;
296  }
297 
298  template<class TCameraParams>
300  {
301  Release();
302  }
303 
304  template<class TCameraParams>
306  {
307  Release();
308  }
309 
310 
311  template<class TCameraParams>
313  {
314  // FileName environment is replaced in CNodeMapFactory ctor
315 
316  // Load the DLL
317  if(_Ptr)
318  throw RUNTIME_EXCEPTION("Node map already created");
319 
320  // Load the XML file
321  CNodeMapFactory nodeMapData(ContentType_Xml, FileName);
322 
323  // First create node map then the reference counter. This prevents a leak in case of bad node map
324  INodeMap* pNodeMap = nodeMapData.CreateNodeMap( _DeviceName );
325  Attach( pNodeMap, _DeviceName, new int( 0 ) );
326  }
327 
328  template<class TCameraParams>
330  {
331  // FileName environment is replaced in CNodeMapFactory ctor
332 
333  // Load the DLL
334  if(_Ptr)
335  throw RUNTIME_EXCEPTION("Node map already created");
336 
337  // Load the XML file
338  CNodeMapFactory nodeMapData(ContentType_ZippedXml, ZipFileName);
339 
340  // First create node map then the reference counter. This prevents a leak in case of bad node map
341  INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
342  Attach( pNodeMap, _DeviceName, new int(0));
343  }
344 
345  template<class TCameraParams>
347  {
348  // xxxFileName environment is replaced in CNodeMapFactory ctor
349 
350  // Load the DLL
351  if(_Ptr)
352  throw RUNTIME_EXCEPTION("Node map already created");
353 
354  // Load the XML file
355  CNodeMapFactory nodeMapData(ContentType_Xml, TargetFileName);
356  CNodeMapFactory injectNodeMapData(ContentType_Xml, InjectFileName);
357  nodeMapData.AddInjectionData(injectNodeMapData);
358 
359  // First create node map then the reference counter. This prevents a leak in case of bad node map
360  INodeMap* pNodeMap = nodeMapData.CreateNodeMap(_DeviceName);
361  Attach( pNodeMap, _DeviceName, new int( 0 ) );
362  }
363 
364  template<class TCameraParams>
366  {
367  // Load the DLL
368  if(_Ptr)
369  throw RUNTIME_EXCEPTION("Node map already created");
370 
371  // Load the XML file
372  CNodeMapFactory nodeMapData(ContentType_Xml, XMLData.c_str(), XMLData.size()); //avoid string copy
373 
374  // First create node map then the reference counter. This prevents a leak in case of bad node map
375  INodeMap* pNodeMap = nodeMapData.CreateNodeMap(_DeviceName);
376  Attach( pNodeMap, _DeviceName, new int( 0 ) );
377  }
378 
379 
380  template<class TCameraParams>
381  inline void CNodeMapRefT<TCameraParams>::_LoadXMLFromZIPData(const void* zipData, size_t zipSize)
382  {
383  // Load the DLL
384  if(_Ptr)
385  throw RUNTIME_EXCEPTION("Node map already created");
386 
387  // Load the XML file
388  CNodeMapFactory nodeMapData(ContentType_ZippedXml, zipData, zipSize);
389 
390  // First create node map then the reference counter. This prevents a leak in case of bad node map
391  INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
392  Attach( pNodeMap, _DeviceName, new int( 0 ) );
393  }
394 
395  template<class TCameraParams>
397  {
398  // Load the DLL
399  if(_Ptr)
400  throw RUNTIME_EXCEPTION("Node map already created");
401 
402  // Load the XML file
403  CNodeMapFactory nodeMapData(ContentType_Xml, TargetXMLData.c_str(), TargetXMLData.size()); //avoid string copy
404  CNodeMapFactory injectNodeMapData(ContentType_Xml, InjectXMLData.c_str(), InjectXMLData.size()); //avoid string copy
405  nodeMapData.AddInjectionData(injectNodeMapData);
406 
407  // First create node map then the reference counter. This prevents a leak in case of bad node map
408  INodeMap* pNodeMap = nodeMapData.CreateNodeMap();
409  Attach( pNodeMap, _DeviceName, new int( 0 ) );
410  }
411 
412  template<class TCameraParams>
413  inline void CNodeMapRefT<TCameraParams>::_GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const
414  {
416  }
417 
418  template<class TCameraParams>
420  {
421  if(_Ptr)
422  return _Ptr->GetDeviceName();
423  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
424  }
425 
426  template<class TCameraParams>
428  {
429  if(_Ptr)
430  return _Ptr->Poll(ElapsedTime);
431  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
432  }
433 
434  template<class TCameraParams>
436  {
437  if(_Ptr)
438  return _Ptr->GetNodes(Nodes);
439  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
440  }
441 
442 
443  template<class TCameraParams>
445  {
446  if (_Ptr)
447  return _Ptr->SetSuppressCallbackMode(mode);
448  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
449  }
450 
451 
452  template<class TCameraParams>
454  {
455  if (_Ptr)
456  return _Ptr->NewNodeWriteConcatenator();
457  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
458  }
459 
460  template<class TCameraParams>
461  inline bool CNodeMapRefT<TCameraParams>::_ConcatenatedWrite(CNodeWriteConcatenator* pConcatenatedWrite, bool featureStreaming, GENICAM_NAMESPACE::gcstring_vector* pErrorList)
462  {
463  if (_Ptr)
464  return _Ptr->ConcatenatedWrite(pConcatenatedWrite, featureStreaming, pErrorList);
465  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
466  }
467 
468  template<class TCameraParams>
470  {
471  if(_Ptr)
472  return _Ptr->GetNode(key);
473  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
474  }
475 
476  template<class TCameraParams>
478  {
479  if(_Ptr)
480  return _Ptr->InvalidateNodes();
481  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
482  }
483 
484  template<class TCameraParams>
485  inline bool CNodeMapRefT<TCameraParams>::_ParseSwissKnifes( GENICAM_NAMESPACE::gcstring_vector *pErrorList ) const
486  {
487  if (_Ptr)
488  return _Ptr->ParseSwissKnifes(pErrorList);
489  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
490  }
491 
492  template<class TCameraParams>
494  {
495  if(_Ptr)
496  return _Ptr->Connect(pPort, PortName);
497  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
498  }
499 
500  template<class TCameraParams>
502  {
503  if(_Ptr)
504  return _Ptr->Connect(pPort);
505  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
506  }
507 
508  template<class TCameraParams>
510  {
511  if (_Ptr)
512  return _Ptr->Connect(pPort, PortName);
513  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
514  }
515 
516  template<class TCameraParams>
518  {
519  if (_Ptr)
520  return _Ptr->Connect(pPort);
521  throw ACCESS_EXCEPTION("Feature not present (reference not valid)");
522  }
523 
524  template<class TCameraParams>
526  {
527  return CNodeMapFactory::ClearCache();
528  }
529 
535  {
536  protected:
539  {
540  // ensure to release all ressources
541  }
542  };
543 
544 
551  class CNodeMapRef : public CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>
552  {
553  public:
555  CNodeMapRef(const GENICAM_NAMESPACE::gcstring &DeviceName = "Device")
557  {
558  }
559 
561  CNodeMapRef(INodeMap* pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName = "Device")
562  : CNodeMapRefT<GENAPI_NAMESPACE::CGeneric_XMLLoaderParams>(pNodeMap, DeviceName)
563  {
564  }
565 
569  {
570  }
571 
574  {
576  return *this;
577  }
578 
581  {
583  return *this;
584  }
585  };
586 
587 }
588 
589 #endif // ifndef GENAPI_NODEMAPPTR_H
GENAPI_NAMESPACE::CGeneric_XMLLoaderParams::~CGeneric_XMLLoaderParams
virtual ~CGeneric_XMLLoaderParams()
Definition: NodeMapRef.h:538
GENAPI_NAMESPACE::CNodeMapRefT::~CNodeMapRefT
virtual ~CNodeMapRefT()
Destructor.
Definition: NodeMapRef.h:299
GENAPI_NAMESPACE
Lexical analyzer for CIntSwissKnife.
Definition: Destructible.h:30
GENAPI_NAMESPACE::CGeneric_XMLLoaderParams
Empty base class used by class CNodeMapRef as generic template argument.
Definition: NodeMapRef.h:534
Pointer.h
Definition of template CPointer.
GENAPI_NAMESPACE::CNodeMapRefT::_DeviceName
GENICAM_NAMESPACE::gcstring _DeviceName
The name of this device.
Definition: NodeMapRef.h:166
GENAPI_NAMESPACE::ContentType_Xml
@ ContentType_Xml
XML camera description file text.
Definition: NodeMapFactory.h:66
IDestroy.h
Definition of interface IDestroy.
GENAPI_NAMESPACE::CNodeMapRefT::_Poll
virtual void _Poll(int64_t ElapsedTime)
Fires nodes which have a polling time.
Definition: NodeMapRef.h:427
GENAPI_NAMESPACE::CNodeMapRefT::_NewNodeWriteConcatenator
virtual CNodeWriteConcatenator * _NewNodeWriteConcatenator() const
Create a new write concatenator object.
Definition: NodeMapRef.h:453
GENAPI_NAMESPACE::CNodeMapRefT::_ClearXMLCache
static bool _ClearXMLCache()
Clears the cache of the camera description files.
Definition: NodeMapRef.h:525
GENAPI_NAMESPACE::CNodeMapRefT::_GetDeviceName
virtual GENICAM_NAMESPACE::gcstring _GetDeviceName() const
Get device name.
Definition: NodeMapRef.h:419
GENAPI_NAMESPACE::CNodeMapRefT::_pRefCount
int * _pRefCount
Definition: NodeMapRef.h:169
GENICAM_NAMESPACE::gcstring
A string class which is a clone of std::string.
Definition: GCString.h:52
GENAPI_NAMESPACE::CNodeMapRefT::_InvalidateNodes
virtual void _InvalidateNodes() const
Invalidates all nodes.
Definition: NodeMapRef.h:477
GENAPI_NAMESPACE::CNodeMapRefT::_ConcatenatedWrite
virtual bool _ConcatenatedWrite(CNodeWriteConcatenator *, bool featureStreaming=true, GENICAM_NAMESPACE::gcstring_vector *pErrorList=NULL)
Execute the transaction.
Definition: NodeMapRef.h:461
GENAPI_NAMESPACE::CNodeMapRef::CNodeMapRef
CNodeMapRef(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName="Device")
Constructor.
Definition: NodeMapRef.h:561
NodeMapFactory.h
Definition of the node map factory.
GENAPI_NAMESPACE::ECallbackSuppressMode
enum GENAPI_NAMESPACE::_ECallbackSuppressMode ECallbackSuppressMode
typedef for callback suppression mod
GENAPI_DECL
#define GENAPI_DECL
Definition: GenApiDll.h:55
GenICamVersion.h
central versioning counters
GENAPI_NAMESPACE::CNodeMapFactory::GetSupportedSchemaVersions
void GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const
GENAPI_NAMESPACE::CNodeMapRefT::Release
void Release()
Definition: NodeMapRef.h:238
INodeMap.h
Definition of interface INodeMap.
GENAPI_NAMESPACE::CGeneric_XMLLoaderParams::_Initialize
virtual void _Initialize(GENAPI_NAMESPACE::INodeMap *)
Definition: NodeMapRef.h:537
GENAPI_NAMESPACE::CNodeMapRefT
Smartpointer template for NodeMaps with create function.
Definition: NodeMapRef.h:67
GENAPI_NAMESPACE::CNodeMapRefT::_GetNode
virtual INode * _GetNode(const GENICAM_NAMESPACE::gcstring &key) const
Retrieves the node from the central map by name.
Definition: NodeMapRef.h:469
GENAPI_NAMESPACE::CNodeMapRefT::_Ptr
INodeMap * _Ptr
Pointer to the NodeMap.
Definition: NodeMapRef.h:162
GENAPI_NAMESPACE::CNodeMapRefT::CNodeMapRefT
CNodeMapRefT(const GENICAM_NAMESPACE::gcstring &DeviceName="Device")
Constructor.
Definition: NodeMapRef.h:177
GENAPI_NAMESPACE::CNodeMapRefT::operator=
CNodeMapRefT & operator=(const CNodeMapRefT &Them)
Assignment.
Definition: NodeMapRef.h:291
GENAPI_NAMESPACE::INodeMap
GENICAM_INTERFACE INodeMap
Interface to access the node map.
Definition: INode.h:52
GENAPI_NAMESPACE::IDestroy
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IDestroy
Interface to destroy an object.
Definition: IDestroy.h:35
GENAPI_NAMESPACE::CNodeMapRefT::_Connect
virtual bool _Connect(IPort *pPort, const GENICAM_NAMESPACE::gcstring &PortName) const
Connects a port to a port node with given name.
Definition: NodeMapRef.h:493
GENAPI_NAMESPACE::CNodeMapRefT::_ParseSwissKnifes
virtual bool _ParseSwissKnifes(GENICAM_NAMESPACE::gcstring_vector *pErrorList=NULL) const
Parse all Swissknife equations.
Definition: NodeMapRef.h:485
GENAPI_NAMESPACE::IPortStacked
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IPortStacked
Interface for ports.
Definition: IPortStacked.h:63
GENAPI_NAMESPACE::CNodeWriteConcatenator
Definition: ConcatenatedWrite.h:37
GENAPI_NAMESPACE::CNodeMapFactory
The node map factory is used for creating node maps from camera description files.
Definition: NodeMapFactory.h:137
GENAPI_NAMESPACE::CNodeMapRef::operator=
CNodeMapRef & operator=(const CNodeMapRef &Them)
Assignment.
Definition: NodeMapRef.h:573
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromFile
void _LoadXMLFromFile(const GENICAM_NAMESPACE::gcstring &FileName)
Creates the object from a XML file with given file name.
Definition: NodeMapRef.h:312
GENAPI_NAMESPACE::INode
GENICAM_INTERFACE INode
Interface common to all nodes.
Definition: ICategory.h:51
GENAPI_NAMESPACE::CastToIDestroy
GENAPI_DECL IDestroy * CastToIDestroy(INodeMap *pNodeMap)
makes sure the dynamic_cast operator is implemented in the DLL (due to a Linux bug)
GENAPI_NAMESPACE::CNodeMapFactory::CreateNodeMap
INodeMap * CreateNodeMap(const GENICAM_NAMESPACE::gcstring &DeviceName="Device", bool DoReleaseCameraDescriptionFileData=true)
Creates a node map from the preprocessed memory internal representation of the camera description fil...
GENAPI_NAMESPACE::CNodeMapRefT::_GetNodes
virtual void _GetNodes(NodeList_t &Nodes) const
Retrieves all nodes in the node map.
Definition: NodeMapRef.h:435
GENAPI_NAMESPACE::CNodeMapFactory::AddInjectionData
void AddInjectionData(CNodeMapFactory &injectionData)
Adds a node map factory representing a camera description file to inject.
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromZIPFile
void _LoadXMLFromZIPFile(const GENICAM_NAMESPACE::gcstring &ZipFileName)
Creates the object from a ZIP'd XML file with given file name.
Definition: NodeMapRef.h:329
GENAPI_NAMESPACE::CNodeMapRef
Smartpointer for NodeMaps with create function.
Definition: NodeMapRef.h:551
GENAPI_NAMESPACE::CNodeMapRefT::_Destroy
void _Destroy()
Destroys the node map.
Definition: NodeMapRef.h:305
GENAPI_NAMESPACE::CNodeMapRef::CNodeMapRef
CNodeMapRef(const GENICAM_NAMESPACE::gcstring &DeviceName="Device")
Constructor.
Definition: NodeMapRef.h:555
ACCESS_EXCEPTION
#define ACCESS_EXCEPTION
Fires a access exception, e.g. throw ACCESS_EXCEPTION("Not everybody")
Definition: GCException.h:253
GENAPI_NAMESPACE::CNodeMapRef::operator=
CNodeMapRef & operator=(INodeMap *pNodeMap)
Assignment of an INodeMap*.
Definition: NodeMapRef.h:580
int64_t
__int64 int64_t
Definition: config-win32.h:21
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromZIPData
void _LoadXMLFromZIPData(const void *zipData, size_t zipSize)
Creates the object from a ZIP'd XML file given in a string.
Definition: NodeMapRef.h:381
GENICAM_NAMESPACE::gcstring::c_str
virtual const char * c_str(void) const
GENAPI_NAMESPACE::CNodeMapRefT::_GetSupportedSchemaVersions
virtual void _GetSupportedSchemaVersions(GENICAM_NAMESPACE::gcstring_vector &SchemaVersions) const
Gets a list of supported schema versions.
Definition: NodeMapRef.h:413
GENAPI_NAMESPACE::IPort
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IPort
Interface for ports.
Definition: IPort.h:57
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromFileInject
void _LoadXMLFromFileInject(const GENICAM_NAMESPACE::gcstring &TargetFileName, const GENICAM_NAMESPACE::gcstring &InjectFileName)
Creates the object from a XML target and an inject file with given file name.
Definition: NodeMapRef.h:346
RUNTIME_EXCEPTION
#define RUNTIME_EXCEPTION
Fires a runtime exception, e.g. throw RUNTIME_EXCEPTION("buh!")
Definition: GCException.h:247
GENAPI_NAMESPACE::CNodeMapRef::CNodeMapRef
CNodeMapRef(const CNodeMapRef &Them)
Copy constructor.
Definition: NodeMapRef.h:567
GCException.h
GENAPI_NAMESPACE::operator=
virtual IBoolean & operator=(bool Value)
Set node value.
Definition: IBoolean.h:64
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromString
void _LoadXMLFromString(const GENICAM_NAMESPACE::gcstring &XMLData)
Creates the object from XML data given in a string.
Definition: NodeMapRef.h:365
GENAPI_NAMESPACE::ContentType_ZippedXml
@ ContentType_ZippedXml
Zipped XML camera description file text.
Definition: NodeMapFactory.h:67
GENICAM_NAMESPACE::gcstring::size
virtual size_t size(void) const
GENAPI_NAMESPACE::CNodeMapRefT::_LoadXMLFromStringInject
void _LoadXMLFromStringInject(const GENICAM_NAMESPACE::gcstring &TargetXMLDataconst, const GENICAM_NAMESPACE::gcstring &InjectXMLData)
Creates the object from XML data given in a string with injection.
Definition: NodeMapRef.h:396
GENAPI_NAMESPACE::CNodeMapRefT::Attach
void Attach(INodeMap *pNodeMap, const GENICAM_NAMESPACE::gcstring &DeviceName, int *pRefCount)
Definition: NodeMapRef.h:206
GENAPI_NAMESPACE::CNodeMapRefT::_SetSuppressCallbackMode
virtual void _SetSuppressCallbackMode(ECallbackSuppressMode) const
Set suppress callback mode.
Definition: NodeMapRef.h:444
GENAPI_NAMESPACE::NodeList_t
node_vector NodeList_t
a list of node references
Definition: INode.h:55
GCString.h
Portable string implementation.


rc_genicam_api
Author(s): Heiko Hirschmueller
autogenerated on Wed Dec 4 2024 03:10:11