- Cal3D 0.11 API Reference -

tinybind.h
1/*
2www.sourceforge.net/projects/tinyxml
3Original code copyright (c) 2004 Eric Ries (tinybind-eric@sneakemail.com)
4
5This software is provided 'as-is', without any express or implied
6warranty. In no event will the authors be held liable for any
7damages arising from the use of this software.
8
9Permission is granted to anyone to use this software for any
10purpose, including commercial applications, and to alter it and
11redistribute it freely, subject to the following restrictions:
12
131. The origin of this software must not be misrepresented; you must
14not claim that you wrote the original software. If you use this
15software in a product, an acknowledgment in the product documentation
16would be appreciated but is not required.
17
182. Altered source versions must be plainly marked as such, and
19must not be misrepresented as being the original software.
20
213. This notice may not be removed or altered from any source
22distribution.
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
40template< class T >
41class Identity : public IdentityBase
42{
43 public:
44 typedef T type;
45
46};
47
48
49
50
51enum MemberSerializeFlags {
52 MemberSerializeFlagsNone = 0,
53 MemberOptional = 1,
54};
55
56class 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
84template<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
92template<class T>
93bool
94BindToXml(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
101template<class T>
102bool
103BindFromXml(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
111template<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
139template<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
148template<class T, class 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
167template<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
183template<class T, class 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
197template<class T, class MT>
198class MemberArrayHolder : public IMemberValuePolicy<T, MT>
199{
200public:
201 MT T::*memberPtr_;
202 size_t len_;
203
204}
205#endif
206
207
208template<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
220template<class T, class MT>
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();
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
257template<class T, class MT, class FromXmlPolicy, class MemberValuePolicy>
259{
260 public:
261 FromXmlPolicy xmlPolicy_;
262 MemberValuePolicy mvPolicy_;
263
265 : xmlPolicy_((IMemberValuePolicy<T, MT> *)&mvPolicy_)
266 {
267 }
268};
269
270
271
272template<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
314template<class T>
315char const *
316ConvertToString( T const & t );
317
318template<class T>
319void
320ConvertFromString( char const * strIn, T * dataOut );
321
322template<class T, class MT>
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
356template<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
532template<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
598template<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
618template<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
680template<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
745template<class T>
746TiXmlBinding<T> const *
747GetTiXmlBinding( T const &, IdentityBase );
748
749
751GetTiXmlBinding( float const &, IdentityBase );
753GetTiXmlBinding( double const &, IdentityBase );
754TiXmlBinding<int> const *
755GetTiXmlBinding( int const &, IdentityBase );
757GetTiXmlBinding( char const * const &, IdentityBase );
759GetTiXmlBinding( std::string const &, IdentityBase );
760
761template<class T, class VecT>
762TiXmlBinding<VecT> const *
763GetTiXmlBinding( std::vector<T> const &, Identity<VecT> )
764{
765 static StlContainerTiXmlBinding<T, VecT> binding(false);
766 return &binding;
767}
768
769template<class T, class VecT>
770TiXmlBinding<VecT> const *
771GetTiXmlBinding( 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:324
Definition tinybind.h:274
Definition tinybind.h:222
Definition tinybind.h:600
Definition tinybind.h:113
Definition tinybind.h:141
Definition tinybind.h:36
Definition tinybind.h:42
Definition tinybind.h:169
Definition tinybind.h:150
Definition tinybind.h:259
Definition tinybind.h:185
Definition tinybind.h:210
Definition tinybind.h:534
Definition tinybind.h:682
Definition tinybind.h:620
Definition tinybind.h:57
Definition tinybind.h:86
The element is a container class.
Definition tinyxml.h:699
const char * Attribute(const char *name) const
Given an attribute name, Attribute() returns the value for the attribute of that name,...
Definition tinyxml.cpp:472
void SetAttribute(const char *name, const char *value)
Sets an attribute of name to a given value.
Definition tinyxml.cpp:539
The parent class for everything in the Document Object Model.
Definition tinyxml.h:290
TiXmlText * ToText() const
Cast to a more defined type. Will return null not of the requested type.
Definition tinyxml.h:516
TiXmlElement * NextSiblingElement() const
Convenience function to get through elements.
Definition tinyxml.cpp:412
TiXmlNode * InsertEndChild(const TiXmlNode &addThis)
Add a new node related to this.
Definition tinyxml.cpp:190
TiXmlNode * FirstChild() const
The first child of this node. Will be null if there are no children.
Definition tinyxml.h:384
const char * Value() const
The meaning of 'value' changes for the specific type of TiXmlNode.
Definition tinyxml.h:356
TiXmlElement * FirstChildElement() const
Convenience function to get through elements.
Definition tinyxml.cpp:383
void SetValue(const char *_value)
Changes the value of the node.
Definition tinyxml.h:367
XML text.
Definition tinyxml.h:849
Definition tinybind.h:80

Generated by The Cal3D Team with Doxygen 1.10.0