- Cal3D 0.11 API Reference -

tinybind.h
1 /*
2 www.sourceforge.net/projects/tinyxml
3 Original code copyright (c) 2004 Eric Ries (tinybind-eric@sneakemail.com)
4 
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any
7 damages arising from the use of this software.
8 
9 Permission is granted to anyone to use this software for any
10 purpose, including commercial applications, and to alter it and
11 redistribute it freely, subject to the following restrictions:
12 
13 1. The origin of this software must not be misrepresented; you must
14 not claim that you wrote the original software. If you use this
15 software in a product, an acknowledgment in the product documentation
16 would be appreciated but is not required.
17 
18 2. Altered source versions must be plainly marked as such, and
19 must not be misrepresented as being the original software.
20 
21 3. This notice may not be removed or altered from any source
22 distribution.
23 */
24 
25 
26 #ifndef TINYBIND_INCLUDED
27 #define TINYBIND_INCLUDED
28 
29 #include "tinyxml.h"
30 
31 #include <vector>
32 #include <list>
33 #include <sstream>
34 
36 {
37  public:
38 };
39 
40 template< class T >
41 class Identity : public IdentityBase
42 {
43  public:
44  typedef T type;
45 
46 };
47 
48 
49 
50 
51 enum MemberSerializeFlags {
52  MemberSerializeFlagsNone = 0,
53  MemberOptional = 1,
54 };
55 
56 class Tag
57 {
58  public:
59  // support up to 3 tags
60  char const * tag_[3];
61 
62 
63  Tag( char const * tagOne = NULL ) {
64  tag_[0] = tagOne;
65  tag_[1] = NULL;
66  tag_[2] = NULL;
67  }
68  Tag( char const * tagOne, char const * tagTwo ) {
69  tag_[0] = tagOne;
70  tag_[1] = tagTwo;
71  tag_[2] = NULL;
72  }
73  Tag( char const * tagOne, char const * tagTwo, char const * tagThree ) {
74  tag_[0] = tagOne;
75  tag_[1] = tagTwo;
76  tag_[2] = tagThree;
77  }
78 };
79 
81  Tag tag_;
82 };
83 
84 template<class T>
86 {
87  public:
88  virtual bool fromXml( cal3d::TiXmlElement const & elem, T * data, SerializeParams const & ) const = 0;
89  virtual bool intoXml(cal3d::TiXmlElement * elem, T const & data, SerializeParams const & ) const = 0;
90 };
91 
92 template<class T>
93 bool
94 BindToXml(cal3d::TiXmlElement * elemOut, T const & dataIn )
95 {
96  TiXmlBinding<T> const * binding = GetTiXmlBinding( dataIn, Identity<T>() );
97  SerializeParams params;
98  return binding->intoXml( elemOut, dataIn, params );
99 }
100 
101 template<class T>
102 bool
103 BindFromXml(cal3d::TiXmlElement const & elemIn, T * dataOut )
104 {
105  TiXmlBinding<T> const * binding = GetTiXmlBinding( *dataOut, Identity<T>() );
106  SerializeParams params;
107  return binding->fromXml( elemIn, dataOut, params );
108 }
109 
110 
111 template<class T>
113 {
114  public:
115  MemberSerializeFlags flags_;
116  Tag tag_;
117  SerializeParams params_;
118 
119  void setFlags( MemberSerializeFlags f ) {
120  flags_ = f;
121  }
122 
123  SerializeParams const & params() {
124  params_.tag_ = tag_;
125  return params_;
126  }
127 
128  virtual char const * tag( int which = 0) { return tag_.tag_[which]; }
129 
130  virtual bool fromXml(cal3d::TiXmlElement const &, T * ) = 0;
131  virtual bool intoXml(cal3d::TiXmlElement *, T const * ) = 0;
132  virtual bool isAttributeMember() = 0;
133 
134 
135 };
136 
137 
138 
139 template<class T, class MT>
141 {
142  public:
143  virtual MT const & getMemberValue( T const * thisPtr ) = 0;
144  virtual void setMemberValue( T * thisPtr, MT const & mv ) = 0;
145 };
146 
147 
148 template<class T, class MT>
149  class MemberFuncHolder : public IMemberValuePolicy<T, MT>
150 {
151  public:
152  MT (T::*getter_)();
153  void (T::*setter_)(MT);
154 
155  virtual MT const & getMemberValue( T const * thisPtr ) {
156  static MT mv;
157  mv = (const_cast<T*>(thisPtr)->*getter_)();
158  return mv;
159  }
160 
161  virtual void setMemberValue( T * thisPtr, MT const & mv ) {
162  (thisPtr->*setter_)(mv);
163  }
164 
165 };
166 
167 template<class T, class MT>
169 {
170  public:
171  MT const & (T::*getter_)();
172  void (T::*setter_)(MT const &);
173 
174  virtual MT const & getMemberValue( T const * thisPtr ) {
175  return (thisPtr->*getter_)();
176  }
177 
178  virtual void setMemberValue( T * thisPtr, MT const & mv ) {
179  (thisPtr->*setter_)(mv);
180  }
181 };
182 
183 template<class T, class MT>
184  class MemberPtrHolder : public IMemberValuePolicy<T, MT>
185 {
186  public:
187  MT T::*memberPtr_;
188  virtual MT const & getMemberValue( T const * thisPtr ) { return thisPtr->*memberPtr_; }
189  virtual void setMemberValue( T * thisPtr, MT const & mv ) {
190  // by casting away const here, we can support member pointers to arrays
191  //assert(false);
192  //thisPtr->*memberPtr_ = const_cast<MT &>(mv);
193  }
194 };
195 
196 #if 0
197 template<class T, class MT>
198 class MemberArrayHolder : public IMemberValuePolicy<T, MT>
199 {
200 public:
201  MT T::*memberPtr_;
202  size_t len_;
203 
204 }
205 #endif
206 
207 
208 template<class T, class MT>
210 {
211  public:
212  MT & (T::*memberRefFunc_)();
213  virtual MT const & getMemberValue( T const * thisPtr ) { return (const_cast<T*>(thisPtr)->*memberRefFunc_)(); }
214  virtual void setMemberValue( T * thisPtr, MT const & mv ) {
215  (thisPtr->*memberRefFunc_)() = mv;
216  }
217 };
218 
219 
220 template<class T, class MT>
221  class FromXmlElement : public IMemberHolder<T>
222 {
223  public:
224  IMemberValuePolicy<T, MT> * mvPolicy_;
226  {
227  mvPolicy_ = mvPolicy;
228  }
229 
230  virtual bool fromXml(cal3d::TiXmlElement const & elem, T * thisPtr)
231  {
232  MT & mv = const_cast<MT &>(mvPolicy_->getMemberValue(thisPtr));
233  TiXmlBinding<MT> const * binding = GetTiXmlBinding( mv, Identity<MT>() );
234  if( binding->fromXml(elem, &mv, IMemberHolder<T>::params()) ) {
235  mvPolicy_->setMemberValue(thisPtr, mv);
236  return true;
237  } else {
238  return false;
239  }
240  }
241 
242  virtual bool intoXml(cal3d::TiXmlElement * elem, T const * thisPtr)
243  {
244  MT const & mv = mvPolicy_->getMemberValue(thisPtr);
245  TiXmlBinding<MT> const * binding = GetTiXmlBinding( mv, Identity<MT>() );
246  std::string oldValue = elem->Value();
247  elem->SetValue( IMemberHolder<T>::tag() );
248  bool ret = binding->intoXml( elem, mv, IMemberHolder<T>::params() );
249  elem->SetValue( oldValue );
250  return ret;
251  }
252 
253  virtual bool isAttributeMember() { return true; }
254 };
255 
256 
257 template<class T, class MT, class FromXmlPolicy, class MemberValuePolicy>
259 {
260  public:
261  FromXmlPolicy xmlPolicy_;
262  MemberValuePolicy mvPolicy_;
263 
264  MemberHolder()
265  : xmlPolicy_((IMemberValuePolicy<T, MT> *)&mvPolicy_)
266  {
267  }
268 };
269 
270 
271 
272 template<class T, class MT>
274 {
275  public:
276  IMemberValuePolicy<T, MT> * mvPolicy_;
278  {
279  mvPolicy_ = mvPolicy;
280  }
281 
282  virtual bool fromXml(cal3d::TiXmlElement const & elem, T * thisPtr)
283  {
284  if( !stricmp(elem.Value(), IMemberHolder<T>::tag()) ) {
285  MT mv;
286  TiXmlBinding<MT> const * binding = GetTiXmlBinding( mv, Identity<MT>() );
287  if( binding->fromXml(elem, &mv, IMemberHolder<T>::params()) ) {
288  mvPolicy_->setMemberValue(thisPtr, mv);
289  return true;
290  } else {
291  return false;
292  }
293  } else {
294  return false;
295  }
296  }
297 
298  virtual bool intoXml(cal3d::TiXmlElement * elem, T const * thisPtr)
299  {
300  MT const & mv = mvPolicy_->getMemberValue(thisPtr);
302  TiXmlBinding<MT> const * binding = GetTiXmlBinding( mv, Identity<MT>() );
303  if( binding->intoXml( &child, mv, IMemberHolder<T>::params() ) ) {
304  elem->InsertEndChild(child);
305  return true;
306  } else {
307  return false;
308  }
309  }
310 
311  virtual bool isAttributeMember() { return false; }
312 };
313 
314 template<class T>
315 char const *
316 ConvertToString( T const & t );
317 
318 template<class T>
319 void
320 ConvertFromString( char const * strIn, T * dataOut );
321 
322 template<class T, class MT>
323  class FromXmlAttribute : public IMemberHolder<T>
324 {
325  public:
326  IMemberValuePolicy<T, MT> * mvPolicy_;
328  {
329  mvPolicy_ = mvPolicy;
330  }
331 
332  virtual bool fromXml(cal3d::TiXmlElement const & elem, T * thisPtr)
333  {
334  MT mv;
335  const char * attributeValue = elem.Attribute( IMemberHolder<T>::tag() );
336  if( attributeValue && *attributeValue ) {
337  ConvertFromString( attributeValue, &mv );
338  mvPolicy_->setMemberValue(thisPtr, mv);
339  return true;
340  } else {
341  return false;
342  }
343  }
344 
345  virtual bool intoXml(cal3d::TiXmlElement * elem, T const * thisPtr)
346  {
347  MT const & mv = mvPolicy_->getMemberValue(thisPtr);
348  char const * attributeValue = ConvertToString( mv );
349  elem->SetAttribute( IMemberHolder<T>::tag(), attributeValue );
350  return true;
351  }
352 
353  virtual bool isAttributeMember() { return true; }
354 };
355 
356 template<class T, class MT>
357  IMemberHolder<T> * Member( MT T::*mp )
358  {
359  typedef FromXmlChildElement<T, MT> XmlPolicy;
360  typedef MemberPtrHolder<T, MT> MemberValuePolicy;
362  MH_Type * mph = new MH_Type();
363  mph->mvPolicy_.memberPtr_ = mp;
364  return &mph->xmlPolicy_;
365  }
366 
367  template<class T, class MT>
368  IMemberHolder<T> * Member(MT & (T::*mp)() )
369  {
370  typedef FromXmlChildElement<T, MT> XmlPolicy;
371  typedef MemberRefFuncHolder<T, MT> MemberValuePolicy;
373  MH_Type * mph = new MH_Type();
374  mph->mvPolicy_.memberRefFunc_ = mp;
375  return &mph->xmlPolicy_;
376  }
377 
378  template<class T, class MT>
379  IMemberHolder<T> * Member( MT (T::*getter)(), void (T::*setter)(MT) )
380  {
381  typedef FromXmlChildElement<T, MT> XmlPolicy;
382  typedef MemberFuncHolder<T, MT> MemberValuePolicy;
384  MH_Type * mph = new MH_Type();
385  mph->mvPolicy_.getter_ = getter;
386  mph->mvPolicy_.setter_ = setter;
387  return &mph->xmlPolicy_;
388  }
389 
390  template<class T, class MT>
391  IMemberHolder<T> * Member( MT (T::*getter)()const, void (T::*setter)(MT) )
392  {
393  typedef FromXmlChildElement<T, MT> XmlPolicy;
394  typedef MemberFuncHolder<T, MT> MemberValuePolicy;
396  MH_Type * mph = new MH_Type();
397  mph->mvPolicy_.getter_ = (MT (T::*)())getter;
398  mph->mvPolicy_.setter_ = setter;
399  return &mph->xmlPolicy_;
400  }
401 
402  template<class T, class MT>
403  IMemberHolder<T> * Member(
404  MT const & (T::*getter)(),
405  void (T::*setter)(MT const &))
406  {
407  typedef FromXmlChildElement<T, MT> XmlPolicy;
408  typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
410  MH_Type * mph = new MH_Type();
411  mph->mvPolicy_.getter_ = getter;
412  mph->mvPolicy_.setter_ = setter;
413  return &mph->xmlPolicy_;
414  }
415 
416 // BEGIN ATTRIBUTE MAKERS
417  template<class T, class MT>
418  IMemberHolder<T> * MemberAttribute( MT T::*mp )
419  {
420  typedef FromXmlAttribute<T, MT> XmlPolicy;
421  typedef MemberPtrHolder<T, MT> MemberValuePolicy;
423  MH_Type * mph = new MH_Type();
424  mph->mvPolicy_.memberPtr_ = mp;
425  return &mph->xmlPolicy_;
426  }
427 
428 #if 0
429  template<class T, class MT>
430  IMemberHolder<T> * MemberAttribute(MT T::*mp, size_t len)
431  {
432  typedef FromXmlAttribute<T, MT> XmlPolicy;
433  typedef MemberArrayHolder<T, MT> MemberValuePolicy;
435  MH_Type * mph = new MH_Type();
436  mph->mvPolicy_.memberPtr_ = mp;
437  mph->mvPolicy_.len = len;
438  return &mph->xmlPolicy_;
439  }
440 #endif
441 
442  template<class T, class MT>
443  IMemberHolder<T> * MemberAttribute( MT (T::*getter)(), void (T::*setter)(MT) )
444  {
445  typedef FromXmlAttribute<T, MT> XmlPolicy;
446  typedef MemberFuncHolder<T, MT> MemberValuePolicy;
448  MH_Type * mph = new MH_Type();
449  mph->mvPolicy_.getter_ = getter;
450  mph->mvPolicy_.setter_ = setter;
451  return &mph->xmlPolicy_;
452  }
453 
454  template<class T, class MT>
455  IMemberHolder<T> * MemberAttribute( MT (T::*getter)() const, void (T::*setter)(MT) )
456  {
457  typedef FromXmlAttribute<T, MT> XmlPolicy;
458  typedef MemberFuncHolder<T, MT> MemberValuePolicy;
460  MH_Type * mph = new MH_Type();
461  mph->mvPolicy_.getter_ = (MT (T::*)())getter;
462  mph->mvPolicy_.setter_ = setter;
463  return &mph->xmlPolicy_;
464  }
465 
466  template<class T, class MT>
467  IMemberHolder<T> * MemberAttribute(
468  MT const & (T::*getter)(),
469  void (T::*setter)(MT const &))
470  {
471  typedef FromXmlAttribute<T, MT> XmlPolicy;
472  typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
474  MH_Type * mph = new MH_Type();
475  mph->mvPolicy_.getter_ = getter;
476  mph->mvPolicy_.setter_ = setter;
477  return &mph->xmlPolicy_;
478  }
479 // END ATTRIBUTE MAKERS
480 
481 // BEGIN PEER MAKERS
482  template<class T, class MT>
483  IMemberHolder<T> * MemberPeer( MT T::*mp )
484  {
485  typedef FromXmlElement<T, MT> XmlPolicy;
486  typedef MemberPtrHolder<T, MT> MemberValuePolicy;
488  MH_Type * mph = new MH_Type();
489  mph->mvPolicy_.memberPtr_ = mp;
490  return &mph->xmlPolicy_;
491  }
492 
493  template<class T, class MT>
494  IMemberHolder<T> * MemberPeer( MT (T::*getter)(), void (T::*setter)(MT) )
495  {
496  typedef FromXmlElement<T, MT> XmlPolicy;
497  typedef MemberFuncHolder<T, MT> MemberValuePolicy;
499  MH_Type * mph = new MH_Type();
500  mph->mvPolicy_.getter_ = getter;
501  mph->mvPolicy_.setter_ = setter;
502  return &mph->xmlPolicy_;
503  }
504 
505  template<class T, class MT>
506  IMemberHolder<T> * MemberPeer(
507  MT const & (T::*getter)(),
508  void (T::*setter)(MT const &))
509  {
510  typedef FromXmlElement<T, MT> XmlPolicy;
511  typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
513  MH_Type * mph = new MH_Type();
514  mph->mvPolicy_.getter_ = getter;
515  mph->mvPolicy_.setter_ = setter;
516  return &mph->xmlPolicy_;
517  }
518 
519  template<class T, class MT>
520  IMemberHolder<T> * MemberPeer(MT & (T::*mp)() )
521  {
522  typedef FromXmlElement<T, MT> XmlPolicy;
523  typedef MemberRefFuncHolder<T, MT> MemberValuePolicy;
525  MH_Type * mph = new MH_Type();
526  mph->mvPolicy_.memberRefFunc_ = mp;
527  return &mph->xmlPolicy_;
528  }
529 
530 // END PEER MAKERS
531 
532 template<class T>
534 {
535  private:
536  std::vector<IMemberHolder<T> *> members_;
537 
538  public:
539  bool empty() const
540  {
541  return members_.empty();
542  }
543 
544  IMemberHolder<T> * AddMember( Tag tag, IMemberHolder<T> * mph )
545  {
546  mph->flags_ = MemberSerializeFlagsNone;
547  mph->tag_ = tag;
548  members_.push_back( mph );
549  return mph;
550  }
551 
552  virtual bool fromXml(cal3d::TiXmlElement const & elem, T * data, SerializeParams const & params ) const
553  {
554  cal3d::TiXmlElement const * child = elem.FirstChildElement();
555  for( size_t i = 0; i < members_.size(); i++ ) {
556  IMemberHolder<T> * mph = members_[i];
557  bool error = false;
558 
559  bool ret;
560  if( mph->isAttributeMember() ) {
561  ret = mph->fromXml( elem, data );
562  } else {
563  if( !child ) {
564  return false;
565  }
566  ret = mph->fromXml( *child, data );
567  }
568  error = !ret;
569  if( mph->isAttributeMember() ) {
570  } else if( !error ) {
571  child = child->NextSiblingElement();
572  }
573 
574  if( error ) {
575  if( mph->isAttributeMember() ){
576  // no problem
577  continue;
578  } else {
579  // error
580  return false;
581  }
582  }
583  }
584  return true;
585  }
586 
587  virtual bool intoXml(cal3d::TiXmlElement * elem, T const & data, SerializeParams const & ) const
588  {
589  for( size_t i = 0; i < members_.size(); i++ ) {
590  IMemberHolder<T> * mph = members_[i];
591  mph->intoXml( elem, &data );
592  }
593  return true;
594  }
595 };
596 
597 
598 template<class T>
600 {
601  public:
602  virtual bool fromXml(cal3d::TiXmlElement const & elem, T * data, SerializeParams const & ) const
603  {
604  cal3d::TiXmlNode * node = elem.FirstChild();
605  cal3d::TiXmlText * nodedata = node->ToText();
606  ConvertFromString( nodedata->Value(), data );
607  return true;
608  }
609 
610  virtual bool intoXml(cal3d::TiXmlElement * elem, T const & data, SerializeParams const & ) const
611  {
612  cal3d::TiXmlText textData( ConvertToString( data ) );
613  elem->InsertEndChild( textData );
614  return true;
615  }
616 };
617 
618 template<class T, class VecT>
620 {
621  public:
622 
623  char const * subTag_;
624  bool useSubTag_;
625  char const * sizeAttributeName_;
626  StlContainerTiXmlBinding(bool useSubTag, char const * st = NULL, char const * sizeAttributeName = NULL)
627  :subTag_(st), useSubTag_(useSubTag), sizeAttributeName_(sizeAttributeName)
628  {
629  }
630 
631  virtual bool fromXml(cal3d::TiXmlElement const & elem, VecT * data, SerializeParams const & params ) const
632  {
633  data->clear();
634  cal3d::TiXmlElement const * child;
635  child = elem.FirstChildElement();
636  if( sizeAttributeName_ ) {
637  int sz = 0;
638  ConvertFromString( elem.Attribute(sizeAttributeName_), &sz );
639  if( sz ) {
640  //data->reserve(sz);
641  }
642  }
643  while(child) {
644  T * value = new T();
645  TiXmlBinding<T> const * binding = GetTiXmlBinding( *value, Identity<T>() );
646  bool ret = binding->fromXml( *child, value, params );
647  data->push_back(*value);
648  if( ! ret ) {
649  return false;
650  }
651  child = child->NextSiblingElement();
652  }
653  return true;
654  }
655 
656  virtual bool intoXml(cal3d::TiXmlElement * elem, VecT const & data, SerializeParams const & params ) const
657  {
658  if( sizeAttributeName_ ) {
659  elem->SetAttribute( sizeAttributeName_, ConvertToString( data.size() ) );
660  }
661  for( typename VecT::const_iterator i = data.begin(); i != data.end(); i++ ) {
662  T const & value = *i;
663  TiXmlBinding<T> const * binding = GetTiXmlBinding( value, Identity<T>() );
664  char const * tag;
665  if( useSubTag_ ) {
666  tag = subTag_;
667  } else {
668  tag = elem->Value();
669  }
670  cal3d::TiXmlElement child(tag);
671  if( ! binding->intoXml( &child, value, params ) ) {
672  return false;
673  }
674  elem->InsertEndChild(child);
675  }
676  return true;
677  }
678  };
679 
680 template<class T, class VecT>
682 {
683  public:
684 
685  char const * subTag_;
686  bool useSubTag_;
687  char const * sizeAttributeName_;
688  StlContainerPtrBinding(bool useSubTag, char const * st = NULL, char const * sizeAttributeName = NULL)
689  :subTag_(st), useSubTag_(useSubTag), sizeAttributeName_(sizeAttributeName)
690  {
691  }
692 
693  virtual bool fromXml(cal3d::TiXmlElement const & elem, VecT * data, SerializeParams const & params ) const
694  {
695  data->clear();
696  cal3d::TiXmlElement const * child;
697  child = elem.FirstChildElement();
698  if( sizeAttributeName_ ) {
699  int sz = 0;
700  ConvertFromString( elem.Attribute(sizeAttributeName_), &sz );
701  if( sz ) {
702  //data->reserve(sz);
703  }
704  }
705  while(child) {
706  T * value = new T();
707  TiXmlBinding<T> const * binding = GetTiXmlBinding( *value, Identity<T>() );
708  bool ret = binding->fromXml( *child, value, params );
709  data->push_back(value);
710  if( ! ret ) {
711  return false;
712  }
713  child = child->NextSiblingElement();
714  }
715  return true;
716  }
717 
718  virtual bool intoXml(cal3d::TiXmlElement * elem, VecT const & data, SerializeParams const & params ) const
719  {
720  if( sizeAttributeName_ ) {
721  elem->SetAttribute( sizeAttributeName_, ConvertToString( data.size() ) );
722  }
723  for( typename VecT::const_iterator i = data.begin(); i != data.end(); i++ ) {
724  T const * value = *i;
725  if( ! value ) {
726  continue;
727  }
728  TiXmlBinding<T> const * binding = GetTiXmlBinding( *value, Identity<T>() );
729  char const * tag;
730  if( useSubTag_ ) {
731  tag = subTag_;
732  } else {
733  tag = elem->Value();
734  }
735  cal3d::TiXmlElement child(tag);
736  if( ! binding->intoXml( &child, *value, params ) ) {
737  return false;
738  }
739  elem->InsertEndChild(child);
740  }
741  return true;
742  }
743  };
744 
745 template<class T>
746 TiXmlBinding<T> const *
747 GetTiXmlBinding( T const &, IdentityBase );
748 
749 
750 TiXmlBinding<float> const *
751 GetTiXmlBinding( float const &, IdentityBase );
752 TiXmlBinding<double> const *
753 GetTiXmlBinding( double const &, IdentityBase );
754 TiXmlBinding<int> const *
755 GetTiXmlBinding( int const &, IdentityBase );
757 GetTiXmlBinding( char const * const &, IdentityBase );
759 GetTiXmlBinding( std::string const &, IdentityBase );
760 
761 template<class T, class VecT>
762 TiXmlBinding<VecT> const *
763 GetTiXmlBinding( std::vector<T> const &, Identity<VecT> )
764 {
765  static StlContainerTiXmlBinding<T, VecT> binding(false);
766  return &binding;
767 }
768 
769 template<class T, class VecT>
770 TiXmlBinding<VecT> const *
771 GetTiXmlBinding( std::list<T> const &, Identity<VecT> )
772 {
773  static StlContainerTiXmlBinding<T, VecT> binding(false);
774  return &binding;
775 }
776 
777 
778 #endif
Definition: tinybind.h:323
Definition: tinybind.h:209
Definition: tinybind.h:140
TiXmlText * ToText() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:516
Definition: tinybind.h:56
Definition: tinybind.h:533
Definition: tinybind.h:41
XML text.
Definition: tinyxml.h:848
Definition: tinybind.h:35
TiXmlElement * NextSiblingElement() const
Convenience function to get through elements.
Definition: tinyxml.cpp:412
Definition: tinybind.h:221
const char * Attribute(const char *name) const
Given an attribute name, Attribute() returns the value for the attribute of that name, or null if none exists.
Definition: tinyxml.cpp:472
const char * Value() const
The meaning of &#39;value&#39; changes for the specific type of TiXmlNode.
Definition: tinyxml.h:356
Definition: tinybind.h:258
Definition: tinybind.h:273
Definition: tinybind.h:599
Definition: tinybind.h:149
TiXmlNode * FirstChild() const
The first child of this node. Will be null if there are no children.
Definition: tinyxml.h:384
TiXmlNode * InsertEndChild(const TiXmlNode &addThis)
Add a new node related to this.
Definition: tinyxml.cpp:190
Definition: tinybind.h:112
TiXmlElement * FirstChildElement() const
Convenience function to get through elements.
Definition: tinyxml.cpp:383
Definition: tinybind.h:681
Definition: tinybind.h:80
Definition: tinybind.h:184
void SetAttribute(const char *name, const char *value)
Sets an attribute of name to a given value.
Definition: tinyxml.cpp:539
The element is a container class.
Definition: tinyxml.h:698
Definition: tinybind.h:168
The parent class for everything in the Document Object Model.
Definition: tinyxml.h:289
Definition: tinybind.h:85
Definition: tinybind.h:619
void SetValue(const char *_value)
Changes the value of the node.
Definition: tinyxml.h:367

Generated by The Cal3D Team with Doxygen 1.8.14