All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Persistence.h
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // (c) 2007 by National Instruments
3 // Project: GenApi
4 // Author: Eric Gross
5 // $Header$
6 //
7 // License: This file is published under the license of the EMVA GenICam Standard Group.
8 // A text file describing the legal terms is included in your installation as 'GenICam_license.pdf'.
9 // If for some reason you are missing this file please contact the EMVA or visit the website
10 // (http://www.genicam.org) for a full copy.
11 //
12 // THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
13 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
14 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
15 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD GROUP
16 // OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
17 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
18 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
19 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
21 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
22 // POSSIBILITY OF SUCH DAMAGE.
23 //-----------------------------------------------------------------------------
30 #ifndef _GENICAM_PERSISTENCE_H
31 #define _GENICAM_PERSISTENCE_H
32 
33 #include <GenApi/Types.h>
34 #include <GenApi/Pointer.h>
35 #include <GenApi/GenApiDll.h>
36 #include <GenApi/SelectorSet.h>
37 #include <list>
38 #include <iostream>
39 #include <cstring>
40 #include <locale>
41 
42 namespace GENAPI_NAMESPACE
43 {
44 
46  GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IPersistScript
47  {
49  virtual void SetInfo(const GENICAM_NAMESPACE::gcstring &Info) = 0;
50 
52  virtual void PersistFeature(IValue& item, CSelectorSet *selectorSet = NULL) = 0;
53  };
54 
57  {
58  public:
60  virtual void SetInfo(const GENICAM_NAMESPACE::gcstring &Info);
61 
63  virtual void PersistFeature(IValue& item, CSelectorSet *selectorSet = NULL);
64 
69 
73  bool LoadFromBag(INodeMap *pNodeMap, bool Verify = true, GENICAM_NAMESPACE::gcstring_vector *pErrorList = NULL);
74 
81  int64_t StoreToBag(INodeMap *pNodeMap, const int MaxNumPersistSkriptEntries = -1, GENICAM_NAMESPACE::gcstring_vector *pFeatureFilter = NULL);
82 
84  bool operator==(const CFeatureBag &FeatureBag) const;
85 
87 
88  virtual void Destroy();
89 
90  virtual const GENICAM_NAMESPACE::gcstring& GetBagName( void ) const;
91  virtual void SetBagName(const GENICAM_NAMESPACE::gcstring& bagName);
92 
94  friend std::istream& operator >>(std::istream &is, CFeatureBag &FeatureBag);
95 
97  friend std::ostream& operator <<(std::ostream &os, const CFeatureBag &FeatureBag);
98 
99 
100  CFeatureBag();
101  CFeatureBag(const CFeatureBag&);
103  virtual ~CFeatureBag();
104  private:
105 
106  CSelectorState* AllocateSelector();
107  void DeleteSelector(CSelectorState*& p);
108 
109  void Clear();
110  void Push(const char *name, const char *value, CSelectorState *ps);
111 
112  const GENICAM_NAMESPACE::gcstring& GetInfo() const;
113 
114  struct Triplet
115  {
119  };
120 
122  {
123  // Ctor / Dtor
124  // -------------------------------------------------------------------------
125  public:
126  const_iterator(Triplet *pTriplet = NULL);
129  // Operators
130  // -------------------------------------------------------------------------
131  public:
132  const Triplet & operator * (void) const;
133  const Triplet * operator -> (void) const;
134  const_iterator & operator ++ (void);
135  const_iterator operator ++ (int);
136  const_iterator & operator += (intptr_t iInc);
137  const_iterator operator + (intptr_t iInc) const;
138  intptr_t operator - (const const_iterator &iter) const;
139  bool operator == (const const_iterator &iter) const;
140  bool operator != (const const_iterator &iter) const;
141 
142  // Member
143  // -------------------------------------------------------------------------
144  protected:
146 
147  };
148  const_iterator GetBegin();
149  const_iterator GetBegin() const;
150  const_iterator GetEnd();
151  const_iterator GetEnd() const;
152  private:
153  struct FeatureBagImpl;
154  FeatureBagImpl *m_pImpl;
155 
156 
157  bool LoadFromBagInternal(INodeMap *pNodeMap, bool Verify /* = true */, GENICAM_NAMESPACE::gcstring_vector *pErrorList = NULL);
158  int64_t StoreToBagInternal(INodeMap *pNodeMap, const int MaxNumPersistSkriptEntries = -1, GENICAM_NAMESPACE::gcstring_vector *pFeatureFilter = NULL);
159 
160  friend class CFeatureBagger;
161  };
162 
164  #define GENAPI_PERSISTENCE_MAGIC "{05D8C294-F295-4dfb-9D01-096BD04049F4}"
165 
167  #define GENAPI_PERSISTENCE_MAGIC_FEATUREBAGGER "{4709CB3C-7322-4460-84C3-DA11DDA09939}"
168 
170  // note: this method must be inlined because it uses istream in the parameter list
171  inline std::istream& EatComments(std::istream &is)
172  {
173  if( is.eof() )
174  {
175  return is;
176  }
177 
178  char FirstCharacter = static_cast<char>(is.peek());
179  while( FirstCharacter == '#' )
180  {
181  is.ignore(1024, '\n');
182  FirstCharacter = static_cast<char>(is.peek());
183  }
184  return is;
185  }
186 
187 #ifndef GENAPI_DONT_USE_DEFAULT_PERSISTENCE_FILE_FORMAT
188  inline char* TrimSpace( char* Name, std::istream& is )
190  {
191  char* pend = Name + strlen( Name );
192  char* pc = Name;
193  for (; pc < pend && std::isspace( *pc, is.getloc() ); ++pc);
194  for (--pend; pc < pend && std::isspace( *pend, is.getloc() ); --pend);
195  pend[1] = '\0';
196 
197  return pc;
198  }
200  {
201  size_t iend =s.length();
202  size_t ibegin = 0;
203  for (; ibegin < iend && std::isspace( s[ibegin], is.getloc() ); ++ibegin);
204  for (--iend; ibegin < iend; --iend)
205  {
206  if (!std::isspace( s[iend], is.getloc() ))
207  break;
208  }
209  if (iend < s.length())
210  {
211  s.erase(iend + 1);
212  }
213  s.erase( 0, ibegin );
214 
215  return s;
216  }
218  // note: this method must be inlined because it uses istream in the parameter list
219  // note: May not be used as inline if called against a library where it is already compiled.
220  inline std::istream& operator >>(std::istream &is, CFeatureBag &FeatureBag)
221  {
222  if( is.eof() )
223  {
224  throw RUNTIME_EXCEPTION("The stream is eof");
225  }
226 
227  FeatureBag.Clear();
228 
229  GENICAM_NAMESPACE::gcstring FirstLine;
230  FirstLine.reserve( 128 );
231  GENICAM_NAMESPACE::getline( is, FirstLine, '\n' );
232  // Check the magic
234  if( GENICAM_NAMESPACE::gcstring::_npos() == FirstLine.find(MagicGUID) )
235  {
237  if( GENICAM_NAMESPACE::gcstring::_npos() == FirstLine.find(MagicGUID) )
238  {
239  throw RUNTIME_EXCEPTION("The stream is not a GenApi feature stream since it is missing the magic GUID in the first line");
240  }
241  throw RUNTIME_EXCEPTION("The stream has been created using the CFeatureBagger class thus must be restored using the CFeatureBagger class as well");
242  }
243 
244  EatComments( is );
245 
246  GENICAM_NAMESPACE::gcstring Name, Value;
247  Name.reserve( 128 );
248  Value.reserve( 128 );
249  while (!is.eof())
250  {
251  GENICAM_NAMESPACE::getline( is, Name, '\t' );
252  if (is.fail()) // if reading from stream failed -> stop reading!
253  {
254  throw RUNTIME_EXCEPTION( "The stream holds excess data" );
255  break;
256  }
257 
258  Name = TrimSpace( Name, is );
259  if (Name.empty())
260  {
261  continue;
262  }
263 
264  CSelectorState *pSelectorState = FeatureBag.AllocateSelector();
265  if (!pSelectorState)
266  {
267  throw RUNTIME_EXCEPTION( "Unable to allocate SelectorState" );
268  }
269 
270 
271  if (is.peek() == '{')
272  {
273  GENICAM_NAMESPACE::getline( is, Value, '\t' );
274  if (is.fail()) // if reading from stream failed -> stop reading!
275  {
276  break;
277  }
278  for (size_t iassign = Value.find_last_of( '=' ); iassign != GENICAM_NAMESPACE::gcstring::_npos(); iassign = Value.find_last_of( '=' ))
279  {
280  const size_t iend = Value.find_last_of( '}');
281  const size_t ibeg = (Value[0] == '{') ? 1 : 0;
282  const size_t rhs_len = iend == GENICAM_NAMESPACE::gcstring::_npos() ? iend : iend - iassign - 1;
283  const size_t lhs_len = iassign - ibeg;
284  GENICAM_NAMESPACE::gcstring selectorName = Value.substr( ibeg, lhs_len );
285  GENICAM_NAMESPACE::gcstring selectorValue = Value.substr( iassign + 1, rhs_len );
286  pSelectorState->AddSelector( selectorName, selectorValue );
288  {
289  break;
290  }
291 
292  GENICAM_NAMESPACE::getline( is, Value, '\t' );
293  if (is.fail())
294  {
295  break;
296  }
297  }
298  }
299  GENICAM_NAMESPACE::getline( is, Value, '\n' );
300  if (Value.empty())
301  {
302  FeatureBag.DeleteSelector(pSelectorState);
303  throw RUNTIME_EXCEPTION( "The stream holds incomplete key - value - set" );
304  }
305  FeatureBag.Push( Name.c_str(), Value.c_str(), pSelectorState );
306 
307  EatComments( is );
308  }
309  return is;
310  }
311 
313  // note: this method must be inlined because it uses ostream in the parameter list
314  // note: May not be used as inline if called against a library where it is already compiled.
315  inline std::ostream& operator <<(std::ostream &os, const CFeatureBag &FeatureBag)
316  {
317  os << "# " GENAPI_PERSISTENCE_MAGIC "\n";
318  if( !FeatureBag.GetInfo().empty() )
319  {
320  os << "# GenApi persistence file (version " << GENAPI_VERSION_MAJOR << "." << GENAPI_VERSION_MINOR << "." << GENAPI_VERSION_SUBMINOR << ")\n";
321  os << "# " << FeatureBag.GetInfo() << "\n";
322  }
323  for (
324  CFeatureBag::const_iterator it = FeatureBag.GetBegin(), end = FeatureBag.GetEnd();
325  it != end;
326  ++it
327  )
328  {
329  const GENICAM_NAMESPACE::gcstring Name(it->name);
330  const GENICAM_NAMESPACE::gcstring Value(it->value);
331  if ((it->pState)->IsEmpty())
332  {
333  os << Name << "\t" << Value << "\n";
334  }
335  else
336  {
337  bool isFirst = true;
338  os << Name << "\t{";
339  (it->pState)->SetFirst();
340  do
341  {
342  if (!isFirst)
343  os << "\t";
344  else
345  isFirst = false;
346  os << (it->pState)->GetNodeName() << "=" << (it->pState)->GetNodeValue();
347  } while ((it->pState)->SetNext());
348  os << "}\t" << Value << "\n";
349  }
350  }
351 
352  return os;
353  }
354 #endif // #ifndef GENAPI_DONT_USE_DEFAULT_PERSISTENCE_FILE_FORMAT
355 
358  {
359  public:
361  {
362  // Ctor / Dtor
363  // -------------------------------------------------------------------------
364  public:
365  const_iterator(CFeatureBag **ppBag = NULL);
366 
367  // Operators
368  // -------------------------------------------------------------------------
369  public:
370  const CFeatureBag & operator * (void) const;
371  const CFeatureBag * operator -> (void) const;
372  const_iterator & operator ++ (void);
373  const_iterator operator ++ (int);
374  const_iterator & operator += (intptr_t iInc);
375  const_iterator operator + (intptr_t iInc) const;
376  intptr_t operator - (const const_iterator &iter) const;
377  bool operator == (const const_iterator &iter) const;
378  bool operator != (const const_iterator &iter) const;
379 
380  // Member
381  // -------------------------------------------------------------------------
382  protected:
384  };
385  explicit CFeatureBagger();
386  virtual ~CFeatureBagger();
387 
396  size_t Bag(INodeMap *pNodeMap, bool handleDefaultNodeMap = true, bool handleUserSets = false, bool handleSequencerSets = false, const int MaxNumPersistSkriptEntries = -1);
397 
401 
405  bool UnBag(INodeMap *pNodeMap, bool Verify = true, GENICAM_NAMESPACE::gcstring_vector *pErrorList = NULL);
406 
408  virtual void SetInfo(const GENICAM_NAMESPACE::gcstring &Info);
409 
410  // Element access
411  // ---------------------------------------------------------------------------
412  virtual const_iterator begin(void) const;
413  virtual const_iterator end(void) const;
414  virtual const CFeatureBag& at(size_t uiIndex) const;
415  virtual size_t size(void) const;
416 
418  friend std::ostream& operator <<(std::ostream &os, const CFeatureBagger &featureBagger);
419 
421  friend std::istream& operator >>(std::istream &is, CFeatureBagger &featureBagger);
422 
423  private:
424  CFeatureBagger(const CFeatureBagger&); // do not allow copy constructor
425  CFeatureBagger& operator=(const CFeatureBagger&); // do not allow assignments
426  CFeatureBag& AddBag(const GENICAM_NAMESPACE::gcstring &bagName);
427  void DeleteAllBags( void );
428  template<class _Ty>
429  void UnBagCustomAction(INodeMap *pNodeMap, _Ty setNodePtr, const GENICAM_NAMESPACE::gcstring& setNodeValue, CCommandPtr saveNodePtr );
430 
431  void *m_pBags;
434  };
435 
436 #ifndef GENAPI_DONT_USE_DEFAULT_PERSISTENCE_FILE_FORMAT
437  // note: this method must be inlined because it uses ostream in the parameter list
439  // note: May not be used as inline if called against a library where it is already compiled.
440  inline std::ostream& operator <<(std::ostream &os, const CFeatureBagger &featureBagger)
441  {
443  if( !featureBagger.m_Info.empty() )
444  {
445  os << "# GenApi CFeatureBagger persistence file (version " << GENAPI_VERSION_MAJOR << "." << GENAPI_VERSION_MINOR << "." << GENAPI_VERSION_SUBMINOR << ")\n";
446  os << "# " << featureBagger.m_Info << "\n";
447  }
448 
450  for (it = featureBagger.begin(); it != featureBagger.end(); it++)
451  {
452  os << "[" << (*it).GetBagName() << "]\n";
453  os << (*it);
454  }
455 
456  return os;
457  }
458 
460  // note: this method must be inlined because it uses istream in the parameter list
461  // note: May not be used as inline if called against a library where it is already compiled.
462  inline std::istream& operator >> (std::istream &is, CFeatureBagger &featureBagger)
463  {
464  if (is.eof())
465  {
466  throw RUNTIME_EXCEPTION("The stream is eof");
467  }
468 
469  // Check the magic
470  GENICAM_NAMESPACE::gcstring FirstLine;
471  GENICAM_NAMESPACE::getline( is, FirstLine, '\n' );
473  bool boCFeatureBagFormatDetected = false;
474  if( GENICAM_NAMESPACE::gcstring::_npos() == FirstLine.find(MagicGUID) )
475  {
477  if( GENICAM_NAMESPACE::gcstring::_npos() == FirstLine.find(MagicGUID) )
478  {
479  throw RUNTIME_EXCEPTION("The stream is not a GenApi feature stream since it is missing the magic GUID in the first line");
480  }
481  boCFeatureBagFormatDetected = true;
482  }
483 
484  std::stringstream currentBagData;
485  if (boCFeatureBagFormatDetected)
486  {
487  currentBagData << FirstLine;
488  }
489  else
490  {
491  EatComments( is );
492  }
493 
494  featureBagger.DeleteAllBags();
495  // Allow to digest the 'CFeatureBag' format using the 'CFeatureBagger' class!
496  CFeatureBag *pBag = boCFeatureBagFormatDetected ? &featureBagger.AddBag("All") : NULL;
497 
498  while (!is.eof())
499  {
501  GENICAM_NAMESPACE::getline(is, line);
502  if (is.fail()) // if reading from stream failed -> stop reading!
503  {
504  break;
505  }
506  if (!line.empty() && (line[0] == '['))
507  {
508  if (!currentBagData.str().empty())
509  {
510  if (pBag)
511  {
512  currentBagData >> (*pBag);
513  }
514  currentBagData.str("");
515  currentBagData.clear();
516  pBag = NULL;
517  }
518  // this is the beginning of a new section
519  const size_t pos = line.find_first_of("]");
520  const GENICAM_NAMESPACE::gcstring bagName(line.substr(1, pos - 1));
521  if( !bagName.empty() )
522  {
523  pBag = &featureBagger.AddBag(bagName);
524  }
525  }
526  else
527  {
528  currentBagData << line << "\n";
529  }
530  }
531  if (!currentBagData.str().empty() && pBag)
532  {
533  currentBagData >> (*pBag);
534  }
535  return is;
536  }
537 #endif // #ifndef GENAPI_DONT_USE_DEFAULT_PERSISTENCE_FILE_FORMAT
538 }
539 
540 #endif //_GENICAM_PERSISTENCE_H
GENAPI_NAMESPACE::ToString
virtual GENICAM_NAMESPACE::gcstring ToString()=0
Returns a string representation of the digit.
GENAPI_NAMESPACE
Lexical analyzer for CIntSwissKnife.
Definition: Destructible.h:30
Pointer.h
Definition of template CPointer.
GENAPI_NAMESPACE::CSelectorSet
The set of selectors selecting a given node.
Definition: SelectorSet.h:41
GENAPI_PERSISTENCE_MAGIC
#define GENAPI_PERSISTENCE_MAGIC
the magic GUID which indicates that the file or buffer is a GenApi stream created by the CFeatureBag ...
Definition: Persistence.h:164
Types.h
Common types used in the public GenApi interface.
GENICAM_NAMESPACE::gcstring::substr
virtual gcstring substr(size_t offset=0, size_t count=GCSTRING_NPOS) const
GENICAM_NAMESPACE::gcstring::empty
virtual bool empty(void) const
GENICAM_INTERFACE
#define GENICAM_INTERFACE
Definition: GenICamFwd.h:33
GENICAM_NAMESPACE::gcstring
A string class which is a clone of std::string.
Definition: GCString.h:52
GENAPI_NAMESPACE::CFeatureBag::Triplet
Definition: Persistence.h:114
GENAPI_NAMESPACE::PersistFeature
virtual void PersistFeature(IValue &item, CSelectorSet *selectorSet=NULL)=0
Stores a feature.
GENAPI_NAMESPACE::CFeatureBag::GetInfo
const GENICAM_NAMESPACE::gcstring & GetInfo() const
GENICAM_NAMESPACE::gcstring::find_last_of
virtual size_t find_last_of(const gcstring &str, size_t offset=GCSTRING_NPOS) const
GENAPI_VERSION_MAJOR
#define GENAPI_VERSION_MAJOR
Definition: GenApiVersion.h:38
GENAPI_DECL
#define GENAPI_DECL
Definition: GenApiDll.h:55
GENAPI_PERSISTENCE_MAGIC_FEATUREBAGGER
#define GENAPI_PERSISTENCE_MAGIC_FEATUREBAGGER
the magic GUID which indicates that the file is a GenApi stream file created by the CFeatureBagger cl...
Definition: Persistence.h:167
GENAPI_NAMESPACE::operator<<
std::ostream & operator<<(std::ostream &os, const CFeatureBag &FeatureBag)
writes out persistent data to a stream
Definition: Persistence.h:315
SelectorSet.h
GENICAM_NAMESPACE::gcstring::reserve
virtual void reserve(size_t n=0)
GENAPI_NAMESPACE::CFeatureBag::m_pImpl
FeatureBagImpl * m_pImpl
Definition: Persistence.h:153
GENAPI_NAMESPACE::CFeatureBag::AllocateSelector
CSelectorState * AllocateSelector()
GENAPI_NAMESPACE::CSelectorState
Definition: SelectorState.h:38
GENAPI_NAMESPACE::Verify
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT bool Verify
Definition: IBoolean.h:61
GENAPI_NAMESPACE::CFeatureBag::GetEnd
const_iterator GetEnd()
GENAPI_NAMESPACE::CFeatureBagger::begin
virtual const_iterator begin(void) const
GENAPI_NAMESPACE::operator*
virtual GENICAM_NAMESPACE::gcstring operator*()=0
Get string node value.
GENAPI_NAMESPACE::CFeatureBag::Triplet::name
GENICAM_NAMESPACE::gcstring name
Definition: Persistence.h:116
GENAPI_NAMESPACE::INodeMap
GENICAM_INTERFACE INodeMap
Interface to access the node map.
Definition: INode.h:52
GENAPI_NAMESPACE::CFeatureBagger::DeleteAllBags
void DeleteAllBags(void)
GENAPI_VERSION_SUBMINOR
#define GENAPI_VERSION_SUBMINOR
Definition: GenApiVersion.h:40
GENAPI_NAMESPACE::CFeatureBag::Push
void Push(const char *name, const char *value, CSelectorState *ps)
GENICAM_NAMESPACE::getline
std::istream & getline(std::istream &is, GENICAM_NAMESPACE::gcstring &str)
STL getline.
Definition: GCString.h:194
GENAPI_NAMESPACE::CFeatureBag::GetBegin
const_iterator GetBegin()
GENAPI_NAMESPACE::CFeatureBag
Bag holding streamable features of a nodetree.
Definition: Persistence.h:56
GENAPI_NAMESPACE::CFeatureBag::Triplet::pState
CSelectorState * pState
Definition: Persistence.h:118
GENICAM_NAMESPACE::gcstring::length
virtual size_t length(void) const
GENAPI_NAMESPACE::CFeatureBagger::const_iterator::_ppb
CFeatureBag ** _ppb
Definition: Persistence.h:383
GENAPI_NAMESPACE::operator==
bool operator==(const MyAlloc< T1 > &, const MyAlloc< T2 > &)
Definition: gcmemory.h:98
GENICAM_NAMESPACE::gcstring::erase
virtual gcstring & erase(size_t pos, size_t len=GCSTRING_NPOS)
GENAPI_NAMESPACE::operator>>
std::istream & operator>>(std::istream &is, CFeatureBag &FeatureBag)
reads in persistent data from a stream
Definition: Persistence.h:220
CLProtocol::Destroy
void Destroy(SerialPortMap &portList)
Definition: CLAllAdapter.h:164
GENAPI_NAMESPACE::CPointer
Encapsulates a GenApi pointer dealing with the dynamic_cast automatically.
Definition: Pointer.h:51
GENAPI_NAMESPACE::CFeatureBagger
Class use to bag features.
Definition: Persistence.h:357
GENAPI_NAMESPACE::IValue
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IValue
Interface for value properties.
Definition: IValue.h:61
GENICAM_NAMESPACE::gcstring::_npos
static size_t _npos(void)
GENAPI_NAMESPACE::CFeatureBagger::m_pBags
void * m_pBags
Definition: Persistence.h:431
int64_t
__int64 int64_t
Definition: config-win32.h:21
GENAPI_NAMESPACE::CSelectorState::AddSelector
void AddSelector(IValue &item)
Add a node the the selector state.
GENICAM_NAMESPACE::gcstring::find_first_of
virtual size_t find_first_of(const gcstring &str, size_t offset=0) const
GENICAM_NAMESPACE::gcstring::c_str
virtual const char * c_str(void) const
GENICAM_NAMESPACE::gcstring::find
virtual size_t find(char ch, size_t offset=0) const
GENAPI_NAMESPACE::CFeatureBag::DeleteSelector
void DeleteSelector(CSelectorState *&p)
GENAPI_NAMESPACE::operator!=
bool operator!=(const MyAlloc< T1 > &, const MyAlloc< T2 > &)
Definition: gcmemory.h:103
GENAPI_NAMESPACE::CFeatureBagger::AddBag
CFeatureBag & AddBag(const GENICAM_NAMESPACE::gcstring &bagName)
GENAPI_VERSION_MINOR
#define GENAPI_VERSION_MINOR
Definition: GenApiVersion.h:39
GENAPI_NAMESPACE::TrimSpace
char * TrimSpace(char *Name, std::istream &is)
Helper function cutting off space characters.
Definition: Persistence.h:189
RUNTIME_EXCEPTION
#define RUNTIME_EXCEPTION
Fires a runtime exception, e.g. throw RUNTIME_EXCEPTION("buh!")
Definition: GCException.h:247
GENAPI_NAMESPACE::CFeatureBagger::const_iterator
Definition: Persistence.h:360
GENAPI_NAMESPACE::EatComments
std::istream & EatComments(std::istream &is)
Helper function ignoring lines starting with comment character '#'.
Definition: Persistence.h:171
GENAPI_NAMESPACE::CFeatureBag::Clear
void Clear()
GENAPI_NAMESPACE::CFeatureBag::const_iterator::m_pTriplet
Triplet * m_pTriplet
Definition: Persistence.h:145
GENAPI_NAMESPACE::operator=
virtual IBoolean & operator=(bool Value)
Set node value.
Definition: IBoolean.h:64
GenApiDll.h
declspec's to be used for GenApi Windows dll
GENAPI_NAMESPACE::CFeatureBagger::end
virtual const_iterator end(void) const
GENAPI_NAMESPACE::CFeatureBagger::m_Info
GENICAM_NAMESPACE::gcstring m_Info
String describing the node map.
Definition: Persistence.h:433
GENAPI_NAMESPACE::IPersistScript
GENICAM_INTERFACE GENAPI_DECL_ABSTRACT IPersistScript
Basic interface to persist values to.
Definition: Persistence.h:47
GENAPI_NAMESPACE::CFeatureBag::const_iterator
Definition: Persistence.h:121
GENAPI_NAMESPACE::CFeatureBag::Triplet::value
GENICAM_NAMESPACE::gcstring value
Definition: Persistence.h:117


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