Hermes2D  3.0
mesh_h2d_xml.cpp
1 // Copyright (C) 2005-2010 Code Synthesis Tools CC
2 //
3 // This program was generated by CodeSynthesis XSD, an XML Schema to
4 // C++ data binding compiler.
5 //
6 // This program is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License version 2 as
8 // published by the Free Software Foundation.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 //
19 // In addition, as a special exception, Code Synthesis Tools CC gives
20 // permission to link this program with the Xerces-C++ library (or with
21 // modified versions of Xerces-C++ that use the same license as Xerces-C++),
22 // and distribute linked combinations including the two. You must obey
23 // the GNU General Public License version 2 in all respects for all of
24 // the code used other than Xerces-C++. If you modify this copy of the
25 // program, you may extend this exception to your version of the program,
26 // but you are not obligated to do so. If you do not wish to do so, delete
27 // this exception statement from your version.
28 //
29 // Furthermore, Code Synthesis Tools CC makes a special exception for
30 // the Free/Libre and Open Source Software (FLOSS) which is described
31 // in the accompanying FLOSSE file.
32 //
33 
34 // Begin prologue.
35 //
36 //
37 // End prologue.
38 
39 #include <xsd/cxx/pre.hxx>
40 
41 #include "mesh_h2d_xml.h"
42 
43 namespace XMLMesh
44 {
45  // variables_type
46  //
47 
49  var () const
50  {
51  return this->var_;
52  }
53 
55  var ()
56  {
57  return this->var_;
58  }
59 
60  void variables_type::
61  var (const var_sequence& s)
62  {
63  this->var_ = s;
64  }
65 
66 
67  // vertices_type
68  //
69 
71  v () const
72  {
73  return this->v_;
74  }
75 
77  v ()
78  {
79  return this->v_;
80  }
81 
82  void vertices_type::
83  v (const v_sequence& s)
84  {
85  this->v_ = s;
86  }
87 
88 
89  // elements_type
90  //
91 
93  el () const
94  {
95  return this->el_;
96  }
97 
99  el ()
100  {
101  return this->el_;
102  }
103 
104  void elements_type::
105  el (const el_sequence& s)
106  {
107  this->el_ = s;
108  }
109 
110 
111  // el_t
112  //
113 
114  const el_t::v1_type& el_t::
115  v1 () const
116  {
117  return this->v1_.get ();
118  }
119 
121  v1 ()
122  {
123  return this->v1_.get ();
124  }
125 
126  void el_t::
127  v1 (const v1_type& x)
128  {
129  this->v1_.set (x);
130  }
131 
132  const el_t::v2_type& el_t::
133  v2 () const
134  {
135  return this->v2_.get ();
136  }
137 
139  v2 ()
140  {
141  return this->v2_.get ();
142  }
143 
144  void el_t::
145  v2 (const v2_type& x)
146  {
147  this->v2_.set (x);
148  }
149 
150  const el_t::v3_type& el_t::
151  v3 () const
152  {
153  return this->v3_.get ();
154  }
155 
157  v3 ()
158  {
159  return this->v3_.get ();
160  }
161 
162  void el_t::
163  v3 (const v3_type& x)
164  {
165  this->v3_.set (x);
166  }
167 
168  const el_t::m_type& el_t::
169  m () const
170  {
171  return this->m_.get ();
172  }
173 
175  m ()
176  {
177  return this->m_.get ();
178  }
179 
180  void el_t::
181  m (const m_type& x)
182  {
183  this->m_.set (x);
184  }
185 
186  void el_t::
187  m (::std::auto_ptr< m_type > x)
188  {
189  this->m_.set (x);
190  }
191 
192 
193  // t_t
194  //
195 
196 
197  // q_t
198  //
199 
200  const q_t::v4_type& q_t::
201  v4 () const
202  {
203  return this->v4_.get ();
204  }
205 
207  v4 ()
208  {
209  return this->v4_.get ();
210  }
211 
212  void q_t::
213  v4 (const v4_type& x)
214  {
215  this->v4_.set (x);
216  }
217 
218 
219  // edges_type
220  //
221 
223  ed () const
224  {
225  return this->ed_;
226  }
227 
229  ed ()
230  {
231  return this->ed_;
232  }
233 
234  void edges_type::
235  ed (const ed_sequence& s)
236  {
237  this->ed_ = s;
238  }
239 
240 
241  // curves_type
242  //
243 
245  arc () const
246  {
247  return this->arc_;
248  }
249 
252  {
253  return this->arc_;
254  }
255 
256  void curves_type::
257  arc (const arc_sequence& s)
258  {
259  this->arc_ = s;
260  }
261 
263  NURBS () const
264  {
265  return this->NURBS_;
266  }
267 
270  {
271  return this->NURBS_;
272  }
273 
274  void curves_type::
276  {
277  this->NURBS_ = s;
278  }
279 
280 
281  // refinements_type
282  //
283 
285  ref () const
286  {
287  return this->ref_;
288  }
289 
292  {
293  return this->ref_;
294  }
295 
296  void refinements_type::
297  ref (const ref_sequence& s)
298  {
299  this->ref_ = s;
300  }
301 
302 
303  // mesh
304  //
305 
307  variables () const
308  {
309  return this->variables_;
310  }
311 
314  {
315  return this->variables_;
316  }
317 
318  void mesh::
320  {
321  this->variables_.set (x);
322  }
323 
324  void mesh::
326  {
327  this->variables_ = x;
328  }
329 
330  void mesh::
331  variables (::std::auto_ptr< variables_type > x)
332  {
333  this->variables_.set (x);
334  }
335 
337  vertices () const
338  {
339  return this->vertices_.get ();
340  }
341 
344  {
345  return this->vertices_.get ();
346  }
347 
348  void mesh::
350  {
351  this->vertices_.set (x);
352  }
353 
354  void mesh::
355  vertices (::std::auto_ptr< vertices_type > x)
356  {
357  this->vertices_.set (x);
358  }
359 
361  elements () const
362  {
363  return this->elements_.get ();
364  }
365 
368  {
369  return this->elements_.get ();
370  }
371 
372  void mesh::
374  {
375  this->elements_.set (x);
376  }
377 
378  void mesh::
379  elements (::std::auto_ptr< elements_type > x)
380  {
381  this->elements_.set (x);
382  }
383 
384  const mesh::edges_type& mesh::
385  edges () const
386  {
387  return this->edges_.get ();
388  }
389 
392  {
393  return this->edges_.get ();
394  }
395 
396  void mesh::
397  edges (const edges_type& x)
398  {
399  this->edges_.set (x);
400  }
401 
402  void mesh::
403  edges (::std::auto_ptr< edges_type > x)
404  {
405  this->edges_.set (x);
406  }
407 
409  curves () const
410  {
411  return this->curves_;
412  }
413 
416  {
417  return this->curves_;
418  }
419 
420  void mesh::
422  {
423  this->curves_.set (x);
424  }
425 
426  void mesh::
428  {
429  this->curves_ = x;
430  }
431 
432  void mesh::
433  curves (::std::auto_ptr< curves_type > x)
434  {
435  this->curves_.set (x);
436  }
437 
439  refinements () const
440  {
441  return this->refinements_;
442  }
443 
446  {
447  return this->refinements_;
448  }
449 
450  void mesh::
452  {
453  this->refinements_.set (x);
454  }
455 
456  void mesh::
458  {
459  this->refinements_ = x;
460  }
461 
462  void mesh::
463  refinements (::std::auto_ptr< refinements_type > x)
464  {
465  this->refinements_.set (x);
466  }
467 
468 
469  // var
470  //
471 
472  const var::name_type& var::
473  name () const
474  {
475  return this->name_.get ();
476  }
477 
480  {
481  return this->name_.get ();
482  }
483 
484  void var::
485  name (const name_type& x)
486  {
487  this->name_.set (x);
488  }
489 
490  void var::
491  name (::std::auto_ptr< name_type > x)
492  {
493  this->name_.set (x);
494  }
495 
496  const var::value_type& var::
497  value () const
498  {
499  return this->value_.get ();
500  }
501 
504  {
505  return this->value_.get ();
506  }
507 
508  void var::
509  value (const value_type& x)
510  {
511  this->value_.set (x);
512  }
513 
514 
515  // v
516  //
517 
518  const v::x_type& v::
519  x () const
520  {
521  return this->x_.get ();
522  }
523 
524  v::x_type& v::
525  x ()
526  {
527  return this->x_.get ();
528  }
529 
530  void v::
531  x (const x_type& x)
532  {
533  this->x_.set (x);
534  }
535 
536  void v::
537  x (::std::auto_ptr< x_type > x)
538  {
539  this->x_.set (x);
540  }
541 
542  const v::y_type& v::
543  y () const
544  {
545  return this->y_.get ();
546  }
547 
548  v::y_type& v::
549  y ()
550  {
551  return this->y_.get ();
552  }
553 
554  void v::
555  y (const y_type& x)
556  {
557  this->y_.set (x);
558  }
559 
560  void v::
561  y (::std::auto_ptr< y_type > x)
562  {
563  this->y_.set (x);
564  }
565 
566  const v::i_type& v::
567  i () const
568  {
569  return this->i_.get ();
570  }
571 
572  v::i_type& v::
573  i ()
574  {
575  return this->i_.get ();
576  }
577 
578  void v::
579  i (const i_type& x)
580  {
581  this->i_.set (x);
582  }
583 
584 
585  // ed
586  //
587 
588  const ed::v1_type& ed::
589  v1 () const
590  {
591  return this->v1_.get ();
592  }
593 
595  v1 ()
596  {
597  return this->v1_.get ();
598  }
599 
600  void ed::
601  v1 (const v1_type& x)
602  {
603  this->v1_.set (x);
604  }
605 
606  const ed::v2_type& ed::
607  v2 () const
608  {
609  return this->v2_.get ();
610  }
611 
613  v2 ()
614  {
615  return this->v2_.get ();
616  }
617 
618  void ed::
619  v2 (const v2_type& x)
620  {
621  this->v2_.set (x);
622  }
623 
624  const ed::m_type& ed::
625  m () const
626  {
627  return this->m_.get ();
628  }
629 
631  m ()
632  {
633  return this->m_.get ();
634  }
635 
636  void ed::
637  m (const m_type& x)
638  {
639  this->m_.set (x);
640  }
641 
642  void ed::
643  m (::std::auto_ptr< m_type > x)
644  {
645  this->m_.set (x);
646  }
647 
648 
649  // arc
650  //
651 
652  const arc::v1_type& arc::
653  v1 () const
654  {
655  return this->v1_.get ();
656  }
657 
659  v1 ()
660  {
661  return this->v1_.get ();
662  }
663 
664  void arc::
665  v1 (const v1_type& x)
666  {
667  this->v1_.set (x);
668  }
669 
670  const arc::v2_type& arc::
671  v2 () const
672  {
673  return this->v2_.get ();
674  }
675 
677  v2 ()
678  {
679  return this->v2_.get ();
680  }
681 
682  void arc::
683  v2 (const v2_type& x)
684  {
685  this->v2_.set (x);
686  }
687 
688  const arc::angle_type& arc::
689  angle () const
690  {
691  return this->angle_.get ();
692  }
693 
696  {
697  return this->angle_.get ();
698  }
699 
700  void arc::
701  angle (const angle_type& x)
702  {
703  this->angle_.set (x);
704  }
705 
706 
707  // NURBS
708  //
709 
711  inner_point () const
712  {
713  return this->inner_point_;
714  }
715 
718  {
719  return this->inner_point_;
720  }
721 
722  void NURBS::
724  {
725  this->inner_point_ = s;
726  }
727 
729  knot () const
730  {
731  return this->knot_;
732  }
733 
736  {
737  return this->knot_;
738  }
739 
740  void NURBS::
742  {
743  this->knot_ = s;
744  }
745 
746  const NURBS::v1_type& NURBS::
747  v1 () const
748  {
749  return this->v1_.get ();
750  }
751 
753  v1 ()
754  {
755  return this->v1_.get ();
756  }
757 
758  void NURBS::
759  v1 (const v1_type& x)
760  {
761  this->v1_.set (x);
762  }
763 
764  const NURBS::v2_type& NURBS::
765  v2 () const
766  {
767  return this->v2_.get ();
768  }
769 
771  v2 ()
772  {
773  return this->v2_.get ();
774  }
775 
776  void NURBS::
777  v2 (const v2_type& x)
778  {
779  this->v2_.set (x);
780  }
781 
782  const NURBS::deg_type& NURBS::
783  deg () const
784  {
785  return this->deg_.get ();
786  }
787 
790  {
791  return this->deg_.get ();
792  }
793 
794  void NURBS::
795  deg (const deg_type& x)
796  {
797  this->deg_.set (x);
798  }
799 
800 
801  // ref
802  //
803 
805  element_id () const
806  {
807  return this->element_id_.get ();
808  }
809 
812  {
813  return this->element_id_.get ();
814  }
815 
816  void ref::
818  {
819  this->element_id_.set (x);
820  }
821 
824  {
825  return this->refinement_type_.get ();
826  }
827 
830  {
831  return this->refinement_type_.get ();
832  }
833 
834  void ref::
836  {
837  this->refinement_type_.set (x);
838  }
839 
840 
841  // inner_point
842  //
843 
845  x () const
846  {
847  return this->x_.get ();
848  }
849 
851  x ()
852  {
853  return this->x_.get ();
854  }
855 
856  void inner_point::
857  x (const x_type& x)
858  {
859  this->x_.set (x);
860  }
861 
863  y () const
864  {
865  return this->y_.get ();
866  }
867 
869  y ()
870  {
871  return this->y_.get ();
872  }
873 
874  void inner_point::
875  y (const y_type& x)
876  {
877  this->y_.set (x);
878  }
879 
881  weight () const
882  {
883  return this->weight_.get ();
884  }
885 
888  {
889  return this->weight_.get ();
890  }
891 
892  void inner_point::
894  {
895  this->weight_.set (x);
896  }
897 
898 
899  // knot
900  //
901 
902  const knot::value_type& knot::
903  value () const
904  {
905  return this->value_.get ();
906  }
907 
910  {
911  return this->value_.get ();
912  }
913 
914  void knot::
915  value (const value_type& x)
916  {
917  this->value_.set (x);
918  }
919 }
920 
921 #include <xsd/cxx/xml/dom/parsing-source.hxx>
922 
923 #include <xsd/cxx/tree/type-factory-map.hxx>
924 
925 namespace _xsd
926 {
927  static
928  const ::xsd::cxx::tree::type_factory_plate< 0, char >
929  type_factory_plate_init;
930 }
931 
932 namespace XMLMesh
933 {
934  // variables_type
935  //
936 
939  : ::xml_schema::type (),
940  var_ (::xml_schema::flags (), this)
941  {
942  }
943 
946  ::xml_schema::flags f,
948  : ::xml_schema::type (x, f, c),
949  var_ (x.var_, f, this)
950  {
951  }
952 
954  variables_type (const ::xercesc::DOMElement& e,
955  ::xml_schema::flags f,
957  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
958  var_ (f, this)
959  {
960  if ((f & ::xml_schema::flags::base) == 0)
961  {
962  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
963  this->parse (p, f);
964  }
965  }
966 
967  void variables_type::
968  parse (::xsd::cxx::xml::dom::parser< char >& p,
969  ::xml_schema::flags f)
970  {
971  for (; p.more_elements (); p.next_element ())
972  {
973  const ::xercesc::DOMElement& i (p.cur_element ());
974  const ::xsd::cxx::xml::qualified_name< char > n (
975  ::xsd::cxx::xml::dom::name< char > (i));
976 
977  // var
978  //
979  if (n.name () == "var" && n.namespace_ ().empty ())
980  {
981  ::std::auto_ptr< var_type > r (
982  var_traits::create (i, f, this));
983 
984  this->var_.push_back (r);
985  continue;
986  }
987 
988  break;
989  }
990  }
991 
992  variables_type* variables_type::
994  ::xml_schema::container* c) const
995  {
996  return new class variables_type (*this, f, c);
997  }
998 
1001  {
1002  }
1003 
1004  // vertices_type
1005  //
1006 
1009  : ::xml_schema::type (),
1010  v_ (::xml_schema::flags (), this)
1011  {
1012  }
1013 
1016  ::xml_schema::flags f,
1017  ::xml_schema::container* c)
1018  : ::xml_schema::type (x, f, c),
1019  v_ (x.v_, f, this)
1020  {
1021  }
1022 
1024  vertices_type (const ::xercesc::DOMElement& e,
1025  ::xml_schema::flags f,
1026  ::xml_schema::container* c)
1027  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1028  v_ (f, this)
1029  {
1030  if ((f & ::xml_schema::flags::base) == 0)
1031  {
1032  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1033  this->parse (p, f);
1034  }
1035  }
1036 
1037  void vertices_type::
1038  parse (::xsd::cxx::xml::dom::parser< char >& p,
1039  ::xml_schema::flags f)
1040  {
1041  for (; p.more_elements (); p.next_element ())
1042  {
1043  const ::xercesc::DOMElement& i (p.cur_element ());
1044  const ::xsd::cxx::xml::qualified_name< char > n (
1045  ::xsd::cxx::xml::dom::name< char > (i));
1046 
1047  // v
1048  //
1049  if (n.name () == "v" && n.namespace_ ().empty ())
1050  {
1051  ::std::auto_ptr< v_type > r (
1052  v_traits::create (i, f, this));
1053 
1054  this->v_.push_back (r);
1055  continue;
1056  }
1057 
1058  break;
1059  }
1060  }
1061 
1062  vertices_type* vertices_type::
1064  ::xml_schema::container* c) const
1065  {
1066  return new class vertices_type (*this, f, c);
1067  }
1068 
1071  {
1072  }
1073 
1074  static
1075  const ::xsd::cxx::tree::element_factory_initializer< 0, char, ::XMLMesh::t_t >
1076  _xsd_t_element_factory_init (
1077  "el",
1078  "XMLMesh",
1079  "t",
1080  "XMLMesh");
1081 
1082 
1083  static
1084  const ::xsd::cxx::tree::element_factory_initializer< 0, char, ::XMLMesh::q_t >
1085  _xsd_q_element_factory_init (
1086  "el",
1087  "XMLMesh",
1088  "q",
1089  "XMLMesh");
1090 
1091 
1092  // elements_type
1093  //
1094 
1097  : ::xml_schema::type (),
1098  el_ (::xml_schema::flags (), this)
1099  {
1100  }
1101 
1104  ::xml_schema::flags f,
1105  ::xml_schema::container* c)
1106  : ::xml_schema::type (x, f, c),
1107  el_ (x.el_, f, this)
1108  {
1109  }
1110 
1112  elements_type (const ::xercesc::DOMElement& e,
1113  ::xml_schema::flags f,
1114  ::xml_schema::container* c)
1115  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1116  el_ (f, this)
1117  {
1118  if ((f & ::xml_schema::flags::base) == 0)
1119  {
1120  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1121  this->parse (p, f);
1122  }
1123  }
1124 
1125  void elements_type::
1126  parse (::xsd::cxx::xml::dom::parser< char >& p,
1127  ::xml_schema::flags f)
1128  {
1129  for (; p.more_elements (); p.next_element ())
1130  {
1131  const ::xercesc::DOMElement& i (p.cur_element ());
1132  const ::xsd::cxx::xml::qualified_name< char > n (
1133  ::xsd::cxx::xml::dom::name< char > (i));
1134 
1135  // el
1136  //
1137  {
1138  ::xsd::cxx::tree::type_factory_map< char >& tfm (
1139  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ());
1140 
1141  ::std::auto_ptr< ::xsd::cxx::tree::type > tmp (
1142  tfm.create (
1143  "el",
1144  "XMLMesh",
1145  &::xsd::cxx::tree::factory_impl< el_type >,
1146  true, true, i, n, f, this));
1147 
1148  if (tmp.get () != 0)
1149  {
1150  ::std::auto_ptr< el_type > r (
1151  dynamic_cast< el_type* > (tmp.get ()));
1152 
1153  if (r.get ())
1154  tmp.release ();
1155  else
1156  throw ::xsd::cxx::tree::not_derived< char > ();
1157 
1158  this->el_.push_back (r);
1159  continue;
1160  }
1161  }
1162 
1163  break;
1164  }
1165  }
1166 
1167  elements_type* elements_type::
1169  ::xml_schema::container* c) const
1170  {
1171  return new class elements_type (*this, f, c);
1172  }
1173 
1176  {
1177  }
1178 
1179  // el_t
1180  //
1181 
1182  el_t::
1183  el_t (const v1_type& v1,
1184  const v2_type& v2,
1185  const v3_type& v3,
1186  const m_type& m)
1187  : ::xml_schema::type (),
1188  v1_ (v1, ::xml_schema::flags (), this),
1189  v2_ (v2, ::xml_schema::flags (), this),
1190  v3_ (v3, ::xml_schema::flags (), this),
1191  m_ (m, ::xml_schema::flags (), this)
1192  {
1193  }
1194 
1195  el_t::
1196  el_t (const el_t& x,
1197  ::xml_schema::flags f,
1198  ::xml_schema::container* c)
1199  : ::xml_schema::type (x, f, c),
1200  v1_ (x.v1_, f, this),
1201  v2_ (x.v2_, f, this),
1202  v3_ (x.v3_, f, this),
1203  m_ (x.m_, f, this)
1204  {
1205  }
1206 
1207  el_t::
1208  el_t (const ::xercesc::DOMElement& e,
1209  ::xml_schema::flags f,
1210  ::xml_schema::container* c)
1211  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1212  v1_ (f, this),
1213  v2_ (f, this),
1214  v3_ (f, this),
1215  m_ (f, this)
1216  {
1217  if ((f & ::xml_schema::flags::base) == 0)
1218  {
1219  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
1220  this->parse (p, f);
1221  }
1222  }
1223 
1224  void el_t::
1225  parse (::xsd::cxx::xml::dom::parser< char >& p,
1226  ::xml_schema::flags f)
1227  {
1228  while (p.more_attributes ())
1229  {
1230  const ::xercesc::DOMAttr& i (p.next_attribute ());
1231  const ::xsd::cxx::xml::qualified_name< char > n (
1232  ::xsd::cxx::xml::dom::name< char > (i));
1233 
1234  if (n.name () == "v1" && n.namespace_ ().empty ())
1235  {
1236  this->v1_.set (v1_traits::create (i, f, this));
1237  continue;
1238  }
1239 
1240  if (n.name () == "v2" && n.namespace_ ().empty ())
1241  {
1242  this->v2_.set (v2_traits::create (i, f, this));
1243  continue;
1244  }
1245 
1246  if (n.name () == "v3" && n.namespace_ ().empty ())
1247  {
1248  this->v3_.set (v3_traits::create (i, f, this));
1249  continue;
1250  }
1251 
1252  if (n.name () == "m" && n.namespace_ ().empty ())
1253  {
1254  ::std::auto_ptr< m_type > r (
1255  m_traits::create (i, f, this));
1256 
1257  this->m_.set (r);
1258  continue;
1259  }
1260  }
1261 
1262  if (!v1_.present ())
1263  {
1264  throw ::xsd::cxx::tree::expected_attribute< char > (
1265  "v1",
1266  "");
1267  }
1268 
1269  if (!v2_.present ())
1270  {
1271  throw ::xsd::cxx::tree::expected_attribute< char > (
1272  "v2",
1273  "");
1274  }
1275 
1276  if (!v3_.present ())
1277  {
1278  throw ::xsd::cxx::tree::expected_attribute< char > (
1279  "v3",
1280  "");
1281  }
1282 
1283  if (!m_.present ())
1284  {
1285  throw ::xsd::cxx::tree::expected_attribute< char > (
1286  "m",
1287  "");
1288  }
1289  }
1290 
1291  el_t* el_t::
1293  ::xml_schema::container* c) const
1294  {
1295  return new class el_t (*this, f, c);
1296  }
1297 
1298  el_t::
1300  {
1301  }
1302 
1303  static
1304  const ::xsd::cxx::tree::type_factory_initializer< 0, char, el_t >
1305  _xsd_el_t_type_factory_init (
1306  "el_t",
1307  "XMLMesh");
1308 
1309  // t_t
1310  //
1311 
1312  t_t::
1313  t_t (const v1_type& v1,
1314  const v2_type& v2,
1315  const v3_type& v3,
1316  const m_type& m)
1317  : ::XMLMesh::el_t (v1,
1318  v2,
1319  v3,
1320  m)
1321  {
1322  }
1323 
1324  t_t::
1325  t_t (const t_t& x,
1326  ::xml_schema::flags f,
1327  ::xml_schema::container* c)
1328  : ::XMLMesh::el_t (x, f, c)
1329  {
1330  }
1331 
1332  t_t::
1333  t_t (const ::xercesc::DOMElement& e,
1334  ::xml_schema::flags f,
1335  ::xml_schema::container* c)
1336  : ::XMLMesh::el_t (e, f, c)
1337  {
1338  }
1339 
1340  t_t* t_t::
1342  ::xml_schema::container* c) const
1343  {
1344  return new class t_t (*this, f, c);
1345  }
1346 
1347  t_t::
1349  {
1350  }
1351 
1352  static
1353  const ::xsd::cxx::tree::type_factory_initializer< 0, char, t_t >
1354  _xsd_t_t_type_factory_init (
1355  "t_t",
1356  "XMLMesh");
1357 
1358  // q_t
1359  //
1360 
1361  q_t::
1362  q_t (const v1_type& v1,
1363  const v2_type& v2,
1364  const v3_type& v3,
1365  const m_type& m,
1366  const v4_type& v4)
1367  : ::XMLMesh::el_t (v1,
1368  v2,
1369  v3,
1370  m),
1371  v4_ (v4, ::xml_schema::flags (), this)
1372  {
1373  }
1374 
1375  q_t::
1376  q_t (const q_t& x,
1377  ::xml_schema::flags f,
1378  ::xml_schema::container* c)
1379  : ::XMLMesh::el_t (x, f, c),
1380  v4_ (x.v4_, f, this)
1381  {
1382  }
1383 
1384  q_t::
1385  q_t (const ::xercesc::DOMElement& e,
1386  ::xml_schema::flags f,
1387  ::xml_schema::container* c)
1388  : ::XMLMesh::el_t (e, f | ::xml_schema::flags::base, c),
1389  v4_ (f, this)
1390  {
1391  if ((f & ::xml_schema::flags::base) == 0)
1392  {
1393  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
1394  this->parse (p, f);
1395  }
1396  }
1397 
1398  void q_t::
1399  parse (::xsd::cxx::xml::dom::parser< char >& p,
1400  ::xml_schema::flags f)
1401  {
1402  this->::XMLMesh::el_t::parse (p, f);
1403 
1404  p.reset_attributes ();
1405 
1406  while (p.more_attributes ())
1407  {
1408  const ::xercesc::DOMAttr& i (p.next_attribute ());
1409  const ::xsd::cxx::xml::qualified_name< char > n (
1410  ::xsd::cxx::xml::dom::name< char > (i));
1411 
1412  if (n.name () == "v4" && n.namespace_ ().empty ())
1413  {
1414  this->v4_.set (v4_traits::create (i, f, this));
1415  continue;
1416  }
1417  }
1418 
1419  if (!v4_.present ())
1420  {
1421  throw ::xsd::cxx::tree::expected_attribute< char > (
1422  "v4",
1423  "");
1424  }
1425  }
1426 
1427  q_t* q_t::
1429  ::xml_schema::container* c) const
1430  {
1431  return new class q_t (*this, f, c);
1432  }
1433 
1434  q_t::
1436  {
1437  }
1438 
1439  static
1440  const ::xsd::cxx::tree::type_factory_initializer< 0, char, q_t >
1441  _xsd_q_t_type_factory_init (
1442  "q_t",
1443  "XMLMesh");
1444 
1445  // edges_type
1446  //
1447 
1448  edges_type::
1450  : ::xml_schema::type (),
1451  ed_ (::xml_schema::flags (), this)
1452  {
1453  }
1454 
1455  edges_type::
1457  ::xml_schema::flags f,
1458  ::xml_schema::container* c)
1459  : ::xml_schema::type (x, f, c),
1460  ed_ (x.ed_, f, this)
1461  {
1462  }
1463 
1464  edges_type::
1465  edges_type (const ::xercesc::DOMElement& e,
1466  ::xml_schema::flags f,
1467  ::xml_schema::container* c)
1468  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1469  ed_ (f, this)
1470  {
1471  if ((f & ::xml_schema::flags::base) == 0)
1472  {
1473  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1474  this->parse (p, f);
1475  }
1476  }
1477 
1478  void edges_type::
1479  parse (::xsd::cxx::xml::dom::parser< char >& p,
1480  ::xml_schema::flags f)
1481  {
1482  for (; p.more_elements (); p.next_element ())
1483  {
1484  const ::xercesc::DOMElement& i (p.cur_element ());
1485  const ::xsd::cxx::xml::qualified_name< char > n (
1486  ::xsd::cxx::xml::dom::name< char > (i));
1487 
1488  // ed
1489  //
1490  if (n.name () == "ed" && n.namespace_ ().empty ())
1491  {
1492  ::std::auto_ptr< ed_type > r (
1493  ed_traits::create (i, f, this));
1494 
1495  this->ed_.push_back (r);
1496  continue;
1497  }
1498 
1499  break;
1500  }
1501  }
1502 
1503  edges_type* edges_type::
1505  ::xml_schema::container* c) const
1506  {
1507  return new class edges_type (*this, f, c);
1508  }
1509 
1510  edges_type::
1512  {
1513  }
1514 
1515  // curves_type
1516  //
1517 
1520  : ::xml_schema::type (),
1521  arc_ (::xml_schema::flags (), this),
1522  NURBS_ (::xml_schema::flags (), this)
1523  {
1524  }
1525 
1528  ::xml_schema::flags f,
1529  ::xml_schema::container* c)
1530  : ::xml_schema::type (x, f, c),
1531  arc_ (x.arc_, f, this),
1532  NURBS_ (x.NURBS_, f, this)
1533  {
1534  }
1535 
1537  curves_type (const ::xercesc::DOMElement& e,
1538  ::xml_schema::flags f,
1539  ::xml_schema::container* c)
1540  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1541  arc_ (f, this),
1542  NURBS_ (f, this)
1543  {
1544  if ((f & ::xml_schema::flags::base) == 0)
1545  {
1546  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1547  this->parse (p, f);
1548  }
1549  }
1550 
1551  void curves_type::
1552  parse (::xsd::cxx::xml::dom::parser< char >& p,
1553  ::xml_schema::flags f)
1554  {
1555  for (; p.more_elements (); p.next_element ())
1556  {
1557  const ::xercesc::DOMElement& i (p.cur_element ());
1558  const ::xsd::cxx::xml::qualified_name< char > n (
1559  ::xsd::cxx::xml::dom::name< char > (i));
1560 
1561  // arc
1562  //
1563  if (n.name () == "arc" && n.namespace_ ().empty ())
1564  {
1565  ::std::auto_ptr< arc_type > r (
1566  arc_traits::create (i, f, this));
1567 
1568  this->arc_.push_back (r);
1569  continue;
1570  }
1571 
1572  // NURBS
1573  //
1574  if (n.name () == "NURBS" && n.namespace_ ().empty ())
1575  {
1576  ::std::auto_ptr< NURBS_type > r (
1577  NURBS_traits::create (i, f, this));
1578 
1579  this->NURBS_.push_back (r);
1580  continue;
1581  }
1582 
1583  break;
1584  }
1585  }
1586 
1587  curves_type* curves_type::
1589  ::xml_schema::container* c) const
1590  {
1591  return new class curves_type (*this, f, c);
1592  }
1593 
1596  {
1597  }
1598 
1599  // refinements_type
1600  //
1601 
1604  : ::xml_schema::type (),
1605  ref_ (::xml_schema::flags (), this)
1606  {
1607  }
1608 
1611  ::xml_schema::flags f,
1612  ::xml_schema::container* c)
1613  : ::xml_schema::type (x, f, c),
1614  ref_ (x.ref_, f, this)
1615  {
1616  }
1617 
1619  refinements_type (const ::xercesc::DOMElement& e,
1620  ::xml_schema::flags f,
1621  ::xml_schema::container* c)
1622  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1623  ref_ (f, this)
1624  {
1625  if ((f & ::xml_schema::flags::base) == 0)
1626  {
1627  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1628  this->parse (p, f);
1629  }
1630  }
1631 
1632  void refinements_type::
1633  parse (::xsd::cxx::xml::dom::parser< char >& p,
1634  ::xml_schema::flags f)
1635  {
1636  for (; p.more_elements (); p.next_element ())
1637  {
1638  const ::xercesc::DOMElement& i (p.cur_element ());
1639  const ::xsd::cxx::xml::qualified_name< char > n (
1640  ::xsd::cxx::xml::dom::name< char > (i));
1641 
1642  // ref
1643  //
1644  if (n.name () == "ref" && n.namespace_ ().empty ())
1645  {
1646  ::std::auto_ptr< ref_type > r (
1647  ref_traits::create (i, f, this));
1648 
1649  this->ref_.push_back (r);
1650  continue;
1651  }
1652 
1653  break;
1654  }
1655  }
1656 
1657  refinements_type* refinements_type::
1659  ::xml_schema::container* c) const
1660  {
1661  return new class refinements_type (*this, f, c);
1662  }
1663 
1666  {
1667  }
1668 
1669  // mesh
1670  //
1671 
1672  mesh::
1673  mesh (const vertices_type& vertices,
1674  const elements_type& elements,
1675  const edges_type& edges)
1676  : ::xml_schema::type (),
1677  variables_ (::xml_schema::flags (), this),
1678  vertices_ (vertices, ::xml_schema::flags (), this),
1679  elements_ (elements, ::xml_schema::flags (), this),
1680  edges_ (edges, ::xml_schema::flags (), this),
1681  curves_ (::xml_schema::flags (), this),
1682  refinements_ (::xml_schema::flags (), this)
1683  {
1684  }
1685 
1686  mesh::
1687  mesh (::std::auto_ptr< vertices_type >& vertices,
1688  ::std::auto_ptr< elements_type >& elements,
1689  ::std::auto_ptr< edges_type >& edges)
1690  : ::xml_schema::type (),
1691  variables_ (::xml_schema::flags (), this),
1692  vertices_ (vertices, ::xml_schema::flags (), this),
1693  elements_ (elements, ::xml_schema::flags (), this),
1694  edges_ (edges, ::xml_schema::flags (), this),
1695  curves_ (::xml_schema::flags (), this),
1696  refinements_ (::xml_schema::flags (), this)
1697  {
1698  }
1699 
1700  mesh::
1701  mesh (const mesh& x,
1702  ::xml_schema::flags f,
1703  ::xml_schema::container* c)
1704  : ::xml_schema::type (x, f, c),
1705  variables_ (x.variables_, f, this),
1706  vertices_ (x.vertices_, f, this),
1707  elements_ (x.elements_, f, this),
1708  edges_ (x.edges_, f, this),
1709  curves_ (x.curves_, f, this),
1710  refinements_ (x.refinements_, f, this)
1711  {
1712  }
1713 
1714  mesh::
1715  mesh (const ::xercesc::DOMElement& e,
1716  ::xml_schema::flags f,
1717  ::xml_schema::container* c)
1718  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1719  variables_ (f, this),
1720  vertices_ (f, this),
1721  elements_ (f, this),
1722  edges_ (f, this),
1723  curves_ (f, this),
1724  refinements_ (f, this)
1725  {
1726  if ((f & ::xml_schema::flags::base) == 0)
1727  {
1728  ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
1729  this->parse (p, f);
1730  }
1731  }
1732 
1733  void mesh::
1734  parse (::xsd::cxx::xml::dom::parser< char >& p,
1735  ::xml_schema::flags f)
1736  {
1737  for (; p.more_elements (); p.next_element ())
1738  {
1739  const ::xercesc::DOMElement& i (p.cur_element ());
1740  const ::xsd::cxx::xml::qualified_name< char > n (
1741  ::xsd::cxx::xml::dom::name< char > (i));
1742 
1743  // variables
1744  //
1745  if (n.name () == "variables" && n.namespace_ ().empty ())
1746  {
1747  ::std::auto_ptr< variables_type > r (
1748  variables_traits::create (i, f, this));
1749 
1750  if (!this->variables_)
1751  {
1752  this->variables_.set (r);
1753  continue;
1754  }
1755  }
1756 
1757  // vertices
1758  //
1759  if (n.name () == "vertices" && n.namespace_ ().empty ())
1760  {
1761  ::std::auto_ptr< vertices_type > r (
1762  vertices_traits::create (i, f, this));
1763 
1764  if (!vertices_.present ())
1765  {
1766  this->vertices_.set (r);
1767  continue;
1768  }
1769  }
1770 
1771  // elements
1772  //
1773  if (n.name () == "elements" && n.namespace_ ().empty ())
1774  {
1775  ::std::auto_ptr< elements_type > r (
1776  elements_traits::create (i, f, this));
1777 
1778  if (!elements_.present ())
1779  {
1780  this->elements_.set (r);
1781  continue;
1782  }
1783  }
1784 
1785  // edges
1786  //
1787  if (n.name () == "edges" && n.namespace_ ().empty ())
1788  {
1789  ::std::auto_ptr< edges_type > r (
1790  edges_traits::create (i, f, this));
1791 
1792  if (!edges_.present ())
1793  {
1794  this->edges_.set (r);
1795  continue;
1796  }
1797  }
1798 
1799  // curves
1800  //
1801  if (n.name () == "curves" && n.namespace_ ().empty ())
1802  {
1803  ::std::auto_ptr< curves_type > r (
1804  curves_traits::create (i, f, this));
1805 
1806  if (!this->curves_)
1807  {
1808  this->curves_.set (r);
1809  continue;
1810  }
1811  }
1812 
1813  // refinements
1814  //
1815  if (n.name () == "refinements" && n.namespace_ ().empty ())
1816  {
1817  ::std::auto_ptr< refinements_type > r (
1818  refinements_traits::create (i, f, this));
1819 
1820  if (!this->refinements_)
1821  {
1822  this->refinements_.set (r);
1823  continue;
1824  }
1825  }
1826 
1827  break;
1828  }
1829 
1830  if (!vertices_.present ())
1831  {
1832  throw ::xsd::cxx::tree::expected_element< char > (
1833  "vertices",
1834  "");
1835  }
1836 
1837  if (!elements_.present ())
1838  {
1839  throw ::xsd::cxx::tree::expected_element< char > (
1840  "elements",
1841  "");
1842  }
1843 
1844  if (!edges_.present ())
1845  {
1846  throw ::xsd::cxx::tree::expected_element< char > (
1847  "edges",
1848  "");
1849  }
1850  }
1851 
1852  mesh* mesh::
1854  ::xml_schema::container* c) const
1855  {
1856  return new class mesh (*this, f, c);
1857  }
1858 
1859  mesh::
1861  {
1862  }
1863 
1864  // var
1865  //
1866 
1867  var::
1869  const value_type& value)
1870  : ::xml_schema::type (),
1871  name_ (name, ::xml_schema::flags (), this),
1872  value_ (value, ::xml_schema::flags (), this)
1873  {
1874  }
1875 
1876  var::
1877  var (const var& x,
1878  ::xml_schema::flags f,
1879  ::xml_schema::container* c)
1880  : ::xml_schema::type (x, f, c),
1881  name_ (x.name_, f, this),
1882  value_ (x.value_, f, this)
1883  {
1884  }
1885 
1886  var::
1887  var (const ::xercesc::DOMElement& e,
1888  ::xml_schema::flags f,
1889  ::xml_schema::container* c)
1890  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1891  name_ (f, this),
1892  value_ (f, this)
1893  {
1894  if ((f & ::xml_schema::flags::base) == 0)
1895  {
1896  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
1897  this->parse (p, f);
1898  }
1899  }
1900 
1901  void var::
1902  parse (::xsd::cxx::xml::dom::parser< char >& p,
1903  ::xml_schema::flags f)
1904  {
1905  while (p.more_attributes ())
1906  {
1907  const ::xercesc::DOMAttr& i (p.next_attribute ());
1908  const ::xsd::cxx::xml::qualified_name< char > n (
1909  ::xsd::cxx::xml::dom::name< char > (i));
1910 
1911  if (n.name () == "name" && n.namespace_ ().empty ())
1912  {
1913  ::std::auto_ptr< name_type > r (
1914  name_traits::create (i, f, this));
1915 
1916  this->name_.set (r);
1917  continue;
1918  }
1919 
1920  if (n.name () == "value" && n.namespace_ ().empty ())
1921  {
1922  this->value_.set (value_traits::create (i, f, this));
1923  continue;
1924  }
1925  }
1926 
1927  if (!name_.present ())
1928  {
1929  throw ::xsd::cxx::tree::expected_attribute< char > (
1930  "name",
1931  "");
1932  }
1933 
1934  if (!value_.present ())
1935  {
1936  throw ::xsd::cxx::tree::expected_attribute< char > (
1937  "value",
1938  "");
1939  }
1940  }
1941 
1942  var* var::
1944  ::xml_schema::container* c) const
1945  {
1946  return new class var (*this, f, c);
1947  }
1948 
1949  var::
1951  {
1952  }
1953 
1954  // v
1955  //
1956 
1957  v::
1958  v (const x_type& x,
1959  const y_type& y,
1960  const i_type& i)
1961  : ::xml_schema::type (),
1962  x_ (x, ::xml_schema::flags (), this),
1963  y_ (y, ::xml_schema::flags (), this),
1964  i_ (i, ::xml_schema::flags (), this)
1965  {
1966  }
1967 
1968  v::
1969  v (const v& x,
1970  ::xml_schema::flags f,
1971  ::xml_schema::container* c)
1972  : ::xml_schema::type (x, f, c),
1973  x_ (x.x_, f, this),
1974  y_ (x.y_, f, this),
1975  i_ (x.i_, f, this)
1976  {
1977  }
1978 
1979  v::
1980  v (const ::xercesc::DOMElement& e,
1981  ::xml_schema::flags f,
1982  ::xml_schema::container* c)
1983  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1984  x_ (f, this),
1985  y_ (f, this),
1986  i_ (f, this)
1987  {
1988  if ((f & ::xml_schema::flags::base) == 0)
1989  {
1990  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
1991  this->parse (p, f);
1992  }
1993  }
1994 
1995  void v::
1996  parse (::xsd::cxx::xml::dom::parser< char >& p,
1997  ::xml_schema::flags f)
1998  {
1999  while (p.more_attributes ())
2000  {
2001  const ::xercesc::DOMAttr& i (p.next_attribute ());
2002  const ::xsd::cxx::xml::qualified_name< char > n (
2003  ::xsd::cxx::xml::dom::name< char > (i));
2004 
2005  if (n.name () == "x" && n.namespace_ ().empty ())
2006  {
2007  ::std::auto_ptr< x_type > r (
2008  x_traits::create (i, f, this));
2009 
2010  this->x_.set (r);
2011  continue;
2012  }
2013 
2014  if (n.name () == "y" && n.namespace_ ().empty ())
2015  {
2016  ::std::auto_ptr< y_type > r (
2017  y_traits::create (i, f, this));
2018 
2019  this->y_.set (r);
2020  continue;
2021  }
2022 
2023  if (n.name () == "i" && n.namespace_ ().empty ())
2024  {
2025  this->i_.set (i_traits::create (i, f, this));
2026  continue;
2027  }
2028  }
2029 
2030  if (!x_.present ())
2031  {
2032  throw ::xsd::cxx::tree::expected_attribute< char > (
2033  "x",
2034  "");
2035  }
2036 
2037  if (!y_.present ())
2038  {
2039  throw ::xsd::cxx::tree::expected_attribute< char > (
2040  "y",
2041  "");
2042  }
2043 
2044  if (!i_.present ())
2045  {
2046  throw ::xsd::cxx::tree::expected_attribute< char > (
2047  "i",
2048  "");
2049  }
2050  }
2051 
2052  v* v::
2054  ::xml_schema::container* c) const
2055  {
2056  return new class v (*this, f, c);
2057  }
2058 
2059  v::
2061  {
2062  }
2063 
2064  // ed
2065  //
2066 
2067  ed::
2068  ed (const v1_type& v1,
2069  const v2_type& v2,
2070  const m_type& m)
2071  : ::xml_schema::type (),
2072  v1_ (v1, ::xml_schema::flags (), this),
2073  v2_ (v2, ::xml_schema::flags (), this),
2074  m_ (m, ::xml_schema::flags (), this)
2075  {
2076  }
2077 
2078  ed::
2079  ed (const ed& x,
2080  ::xml_schema::flags f,
2081  ::xml_schema::container* c)
2082  : ::xml_schema::type (x, f, c),
2083  v1_ (x.v1_, f, this),
2084  v2_ (x.v2_, f, this),
2085  m_ (x.m_, f, this)
2086  {
2087  }
2088 
2089  ed::
2090  ed (const ::xercesc::DOMElement& e,
2091  ::xml_schema::flags f,
2092  ::xml_schema::container* c)
2093  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2094  v1_ (f, this),
2095  v2_ (f, this),
2096  m_ (f, this)
2097  {
2098  if ((f & ::xml_schema::flags::base) == 0)
2099  {
2100  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
2101  this->parse (p, f);
2102  }
2103  }
2104 
2105  void ed::
2106  parse (::xsd::cxx::xml::dom::parser< char >& p,
2107  ::xml_schema::flags f)
2108  {
2109  while (p.more_attributes ())
2110  {
2111  const ::xercesc::DOMAttr& i (p.next_attribute ());
2112  const ::xsd::cxx::xml::qualified_name< char > n (
2113  ::xsd::cxx::xml::dom::name< char > (i));
2114 
2115  if (n.name () == "v1" && n.namespace_ ().empty ())
2116  {
2117  this->v1_.set (v1_traits::create (i, f, this));
2118  continue;
2119  }
2120 
2121  if (n.name () == "v2" && n.namespace_ ().empty ())
2122  {
2123  this->v2_.set (v2_traits::create (i, f, this));
2124  continue;
2125  }
2126 
2127  if (n.name () == "m" && n.namespace_ ().empty ())
2128  {
2129  ::std::auto_ptr< m_type > r (
2130  m_traits::create (i, f, this));
2131 
2132  this->m_.set (r);
2133  continue;
2134  }
2135  }
2136 
2137  if (!v1_.present ())
2138  {
2139  throw ::xsd::cxx::tree::expected_attribute< char > (
2140  "v1",
2141  "");
2142  }
2143 
2144  if (!v2_.present ())
2145  {
2146  throw ::xsd::cxx::tree::expected_attribute< char > (
2147  "v2",
2148  "");
2149  }
2150 
2151  if (!m_.present ())
2152  {
2153  throw ::xsd::cxx::tree::expected_attribute< char > (
2154  "m",
2155  "");
2156  }
2157  }
2158 
2159  ed* ed::
2161  ::xml_schema::container* c) const
2162  {
2163  return new class ed (*this, f, c);
2164  }
2165 
2166  ed::
2168  {
2169  }
2170 
2171  // arc
2172  //
2173 
2174  arc::
2175  arc (const v1_type& v1,
2176  const v2_type& v2,
2177  const angle_type& angle)
2178  : ::xml_schema::type (),
2179  v1_ (v1, ::xml_schema::flags (), this),
2180  v2_ (v2, ::xml_schema::flags (), this),
2181  angle_ (angle, ::xml_schema::flags (), this)
2182  {
2183  }
2184 
2185  arc::
2186  arc (const arc& x,
2187  ::xml_schema::flags f,
2188  ::xml_schema::container* c)
2189  : ::xml_schema::type (x, f, c),
2190  v1_ (x.v1_, f, this),
2191  v2_ (x.v2_, f, this),
2192  angle_ (x.angle_, f, this)
2193  {
2194  }
2195 
2196  arc::
2197  arc (const ::xercesc::DOMElement& e,
2198  ::xml_schema::flags f,
2199  ::xml_schema::container* c)
2200  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2201  v1_ (f, this),
2202  v2_ (f, this),
2203  angle_ (f, this)
2204  {
2205  if ((f & ::xml_schema::flags::base) == 0)
2206  {
2207  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
2208  this->parse (p, f);
2209  }
2210  }
2211 
2212  void arc::
2213  parse (::xsd::cxx::xml::dom::parser< char >& p,
2214  ::xml_schema::flags f)
2215  {
2216  while (p.more_attributes ())
2217  {
2218  const ::xercesc::DOMAttr& i (p.next_attribute ());
2219  const ::xsd::cxx::xml::qualified_name< char > n (
2220  ::xsd::cxx::xml::dom::name< char > (i));
2221 
2222  if (n.name () == "v1" && n.namespace_ ().empty ())
2223  {
2224  this->v1_.set (v1_traits::create (i, f, this));
2225  continue;
2226  }
2227 
2228  if (n.name () == "v2" && n.namespace_ ().empty ())
2229  {
2230  this->v2_.set (v2_traits::create (i, f, this));
2231  continue;
2232  }
2233 
2234  if (n.name () == "angle" && n.namespace_ ().empty ())
2235  {
2236  this->angle_.set (angle_traits::create (i, f, this));
2237  continue;
2238  }
2239  }
2240 
2241  if (!v1_.present ())
2242  {
2243  throw ::xsd::cxx::tree::expected_attribute< char > (
2244  "v1",
2245  "");
2246  }
2247 
2248  if (!v2_.present ())
2249  {
2250  throw ::xsd::cxx::tree::expected_attribute< char > (
2251  "v2",
2252  "");
2253  }
2254 
2255  if (!angle_.present ())
2256  {
2257  throw ::xsd::cxx::tree::expected_attribute< char > (
2258  "angle",
2259  "");
2260  }
2261  }
2262 
2263  arc* arc::
2265  ::xml_schema::container* c) const
2266  {
2267  return new class arc (*this, f, c);
2268  }
2269 
2270  arc::
2272  {
2273  }
2274 
2275  // NURBS
2276  //
2277 
2278  NURBS::
2279  NURBS (const v1_type& v1,
2280  const v2_type& v2,
2281  const deg_type& deg)
2282  : ::xml_schema::type (),
2283  inner_point_ (::xml_schema::flags (), this),
2284  knot_ (::xml_schema::flags (), this),
2285  v1_ (v1, ::xml_schema::flags (), this),
2286  v2_ (v2, ::xml_schema::flags (), this),
2287  deg_ (deg, ::xml_schema::flags (), this)
2288  {
2289  }
2290 
2291  NURBS::
2292  NURBS (const NURBS& x,
2293  ::xml_schema::flags f,
2294  ::xml_schema::container* c)
2295  : ::xml_schema::type (x, f, c),
2296  inner_point_ (x.inner_point_, f, this),
2297  knot_ (x.knot_, f, this),
2298  v1_ (x.v1_, f, this),
2299  v2_ (x.v2_, f, this),
2300  deg_ (x.deg_, f, this)
2301  {
2302  }
2303 
2304  NURBS::
2305  NURBS (const ::xercesc::DOMElement& e,
2306  ::xml_schema::flags f,
2307  ::xml_schema::container* c)
2308  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2309  inner_point_ (f, this),
2310  knot_ (f, this),
2311  v1_ (f, this),
2312  v2_ (f, this),
2313  deg_ (f, this)
2314  {
2315  if ((f & ::xml_schema::flags::base) == 0)
2316  {
2317  ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
2318  this->parse (p, f);
2319  }
2320  }
2321 
2322  void NURBS::
2323  parse (::xsd::cxx::xml::dom::parser< char >& p,
2324  ::xml_schema::flags f)
2325  {
2326  for (; p.more_elements (); p.next_element ())
2327  {
2328  const ::xercesc::DOMElement& i (p.cur_element ());
2329  const ::xsd::cxx::xml::qualified_name< char > n (
2330  ::xsd::cxx::xml::dom::name< char > (i));
2331 
2332  // inner_point
2333  //
2334  if (n.name () == "inner_point" && n.namespace_ ().empty ())
2335  {
2336  ::std::auto_ptr< inner_point_type > r (
2337  inner_point_traits::create (i, f, this));
2338 
2339  this->inner_point_.push_back (r);
2340  continue;
2341  }
2342 
2343  // knot
2344  //
2345  if (n.name () == "knot" && n.namespace_ ().empty ())
2346  {
2347  ::std::auto_ptr< knot_type > r (
2348  knot_traits::create (i, f, this));
2349 
2350  this->knot_.push_back (r);
2351  continue;
2352  }
2353 
2354  break;
2355  }
2356 
2357  while (p.more_attributes ())
2358  {
2359  const ::xercesc::DOMAttr& i (p.next_attribute ());
2360  const ::xsd::cxx::xml::qualified_name< char > n (
2361  ::xsd::cxx::xml::dom::name< char > (i));
2362 
2363  if (n.name () == "v1" && n.namespace_ ().empty ())
2364  {
2365  this->v1_.set (v1_traits::create (i, f, this));
2366  continue;
2367  }
2368 
2369  if (n.name () == "v2" && n.namespace_ ().empty ())
2370  {
2371  this->v2_.set (v2_traits::create (i, f, this));
2372  continue;
2373  }
2374 
2375  if (n.name () == "deg" && n.namespace_ ().empty ())
2376  {
2377  this->deg_.set (deg_traits::create (i, f, this));
2378  continue;
2379  }
2380  }
2381 
2382  if (!v1_.present ())
2383  {
2384  throw ::xsd::cxx::tree::expected_attribute< char > (
2385  "v1",
2386  "");
2387  }
2388 
2389  if (!v2_.present ())
2390  {
2391  throw ::xsd::cxx::tree::expected_attribute< char > (
2392  "v2",
2393  "");
2394  }
2395 
2396  if (!deg_.present ())
2397  {
2398  throw ::xsd::cxx::tree::expected_attribute< char > (
2399  "deg",
2400  "");
2401  }
2402  }
2403 
2404  NURBS* NURBS::
2406  ::xml_schema::container* c) const
2407  {
2408  return new class NURBS (*this, f, c);
2409  }
2410 
2411  NURBS::
2413  {
2414  }
2415 
2416  // ref
2417  //
2418 
2419  ref::
2420  ref (const element_id_type& element_id,
2421  const refinement_type_type& refinement_type)
2422  : ::xml_schema::type (),
2423  element_id_ (element_id, ::xml_schema::flags (), this),
2424  refinement_type_ (refinement_type, ::xml_schema::flags (), this)
2425  {
2426  }
2427 
2428  ref::
2429  ref (const ref& x,
2430  ::xml_schema::flags f,
2431  ::xml_schema::container* c)
2432  : ::xml_schema::type (x, f, c),
2433  element_id_ (x.element_id_, f, this),
2434  refinement_type_ (x.refinement_type_, f, this)
2435  {
2436  }
2437 
2438  ref::
2439  ref (const ::xercesc::DOMElement& e,
2440  ::xml_schema::flags f,
2441  ::xml_schema::container* c)
2442  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2443  element_id_ (f, this),
2444  refinement_type_ (f, this)
2445  {
2446  if ((f & ::xml_schema::flags::base) == 0)
2447  {
2448  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
2449  this->parse (p, f);
2450  }
2451  }
2452 
2453  void ref::
2454  parse (::xsd::cxx::xml::dom::parser< char >& p,
2455  ::xml_schema::flags f)
2456  {
2457  while (p.more_attributes ())
2458  {
2459  const ::xercesc::DOMAttr& i (p.next_attribute ());
2460  const ::xsd::cxx::xml::qualified_name< char > n (
2461  ::xsd::cxx::xml::dom::name< char > (i));
2462 
2463  if (n.name () == "element_id" && n.namespace_ ().empty ())
2464  {
2465  this->element_id_.set (element_id_traits::create (i, f, this));
2466  continue;
2467  }
2468 
2469  if (n.name () == "refinement_type" && n.namespace_ ().empty ())
2470  {
2471  this->refinement_type_.set (refinement_type_traits::create (i, f, this));
2472  continue;
2473  }
2474  }
2475 
2476  if (!element_id_.present ())
2477  {
2478  throw ::xsd::cxx::tree::expected_attribute< char > (
2479  "element_id",
2480  "");
2481  }
2482 
2483  if (!refinement_type_.present ())
2484  {
2485  throw ::xsd::cxx::tree::expected_attribute< char > (
2486  "refinement_type",
2487  "");
2488  }
2489  }
2490 
2491  ref* ref::
2493  ::xml_schema::container* c) const
2494  {
2495  return new class ref (*this, f, c);
2496  }
2497 
2498  ref::
2500  {
2501  }
2502 
2503  // inner_point
2504  //
2505 
2508  const y_type& y,
2509  const weight_type& weight)
2510  : ::xml_schema::type (),
2511  x_ (x, ::xml_schema::flags (), this),
2512  y_ (y, ::xml_schema::flags (), this),
2513  weight_ (weight, ::xml_schema::flags (), this)
2514  {
2515  }
2516 
2519  ::xml_schema::flags f,
2520  ::xml_schema::container* c)
2521  : ::xml_schema::type (x, f, c),
2522  x_ (x.x_, f, this),
2523  y_ (x.y_, f, this),
2524  weight_ (x.weight_, f, this)
2525  {
2526  }
2527 
2529  inner_point (const ::xercesc::DOMElement& e,
2530  ::xml_schema::flags f,
2531  ::xml_schema::container* c)
2532  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2533  x_ (f, this),
2534  y_ (f, this),
2535  weight_ (f, this)
2536  {
2537  if ((f & ::xml_schema::flags::base) == 0)
2538  {
2539  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
2540  this->parse (p, f);
2541  }
2542  }
2543 
2544  void inner_point::
2545  parse (::xsd::cxx::xml::dom::parser< char >& p,
2546  ::xml_schema::flags f)
2547  {
2548  while (p.more_attributes ())
2549  {
2550  const ::xercesc::DOMAttr& i (p.next_attribute ());
2551  const ::xsd::cxx::xml::qualified_name< char > n (
2552  ::xsd::cxx::xml::dom::name< char > (i));
2553 
2554  if (n.name () == "x" && n.namespace_ ().empty ())
2555  {
2556  this->x_.set (x_traits::create (i, f, this));
2557  continue;
2558  }
2559 
2560  if (n.name () == "y" && n.namespace_ ().empty ())
2561  {
2562  this->y_.set (y_traits::create (i, f, this));
2563  continue;
2564  }
2565 
2566  if (n.name () == "weight" && n.namespace_ ().empty ())
2567  {
2568  this->weight_.set (weight_traits::create (i, f, this));
2569  continue;
2570  }
2571  }
2572 
2573  if (!x_.present ())
2574  {
2575  throw ::xsd::cxx::tree::expected_attribute< char > (
2576  "x",
2577  "");
2578  }
2579 
2580  if (!y_.present ())
2581  {
2582  throw ::xsd::cxx::tree::expected_attribute< char > (
2583  "y",
2584  "");
2585  }
2586 
2587  if (!weight_.present ())
2588  {
2589  throw ::xsd::cxx::tree::expected_attribute< char > (
2590  "weight",
2591  "");
2592  }
2593  }
2594 
2595  inner_point* inner_point::
2597  ::xml_schema::container* c) const
2598  {
2599  return new class inner_point (*this, f, c);
2600  }
2601 
2604  {
2605  }
2606 
2607  // knot
2608  //
2609 
2610  knot::
2611  knot (const value_type& value)
2612  : ::xml_schema::type (),
2613  value_ (value, ::xml_schema::flags (), this)
2614  {
2615  }
2616 
2617  knot::
2618  knot (const knot& x,
2619  ::xml_schema::flags f,
2620  ::xml_schema::container* c)
2621  : ::xml_schema::type (x, f, c),
2622  value_ (x.value_, f, this)
2623  {
2624  }
2625 
2626  knot::
2627  knot (const ::xercesc::DOMElement& e,
2628  ::xml_schema::flags f,
2629  ::xml_schema::container* c)
2630  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2631  value_ (f, this)
2632  {
2633  if ((f & ::xml_schema::flags::base) == 0)
2634  {
2635  ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
2636  this->parse (p, f);
2637  }
2638  }
2639 
2640  void knot::
2641  parse (::xsd::cxx::xml::dom::parser< char >& p,
2642  ::xml_schema::flags f)
2643  {
2644  while (p.more_attributes ())
2645  {
2646  const ::xercesc::DOMAttr& i (p.next_attribute ());
2647  const ::xsd::cxx::xml::qualified_name< char > n (
2648  ::xsd::cxx::xml::dom::name< char > (i));
2649 
2650  if (n.name () == "value" && n.namespace_ ().empty ())
2651  {
2652  this->value_.set (value_traits::create (i, f, this));
2653  continue;
2654  }
2655  }
2656 
2657  if (!value_.present ())
2658  {
2659  throw ::xsd::cxx::tree::expected_attribute< char > (
2660  "value",
2661  "");
2662  }
2663  }
2664 
2665  knot* knot::
2667  ::xml_schema::container* c) const
2668  {
2669  return new class knot (*this, f, c);
2670  }
2671 
2672  knot::
2674  {
2675  }
2676 }
2677 
2678 #include <ostream>
2679 
2680 #include <xsd/cxx/tree/std-ostream-map.hxx>
2681 
2682 namespace _xsd
2683 {
2684  static
2685  const ::xsd::cxx::tree::std_ostream_plate< 0, char >
2686  std_ostream_plate_init;
2687 }
2688 
2689 namespace XMLMesh
2690 {
2691  ::std::ostream&
2692  operator<< (::std::ostream& o, const variables_type& i)
2693  {
2695  b (i.var ().begin ()), e (i.var ().end ());
2696  b != e; ++b)
2697  {
2698  o << ::std::endl << "var: " << *b;
2699  }
2700 
2701  return o;
2702  }
2703 
2704  ::std::ostream&
2705  operator<< (::std::ostream& o, const vertices_type& i)
2706  {
2708  b (i.v ().begin ()), e (i.v ().end ());
2709  b != e; ++b)
2710  {
2711  o << ::std::endl << "v: " << *b;
2712  }
2713 
2714  return o;
2715  }
2716 
2717  ::std::ostream&
2718  operator<< (::std::ostream& o, const elements_type& i)
2719  {
2720  {
2721  ::xsd::cxx::tree::std_ostream_map< char >& om (
2722  ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
2723 
2725  b (i.el ().begin ()), e (i.el ().end ());
2726  b != e; ++b)
2727  {
2728  o << ::std::endl << "el: ";
2729  om.insert (o, *b);
2730  }
2731  }
2732 
2733  return o;
2734  }
2735 
2736  ::std::ostream&
2737  operator<< (::std::ostream& o, const el_t& i)
2738  {
2739  o << ::std::endl << "v1: " << i.v1 ();
2740  o << ::std::endl << "v2: " << i.v2 ();
2741  o << ::std::endl << "v3: " << i.v3 ();
2742  o << ::std::endl << "m: " << i.m ();
2743  return o;
2744  }
2745 
2746  static
2747  const ::xsd::cxx::tree::std_ostream_initializer< 0, char, el_t >
2748  _xsd_el_t_std_ostream_init;
2749 
2750  ::std::ostream&
2751  operator<< (::std::ostream& o, const t_t& i)
2752  {
2753  o << static_cast< const ::XMLMesh::el_t& > (i);
2754 
2755  return o;
2756  }
2757 
2758  static
2759  const ::xsd::cxx::tree::std_ostream_initializer< 0, char, t_t >
2760  _xsd_t_t_std_ostream_init;
2761 
2762  ::std::ostream&
2763  operator<< (::std::ostream& o, const q_t& i)
2764  {
2765  o << static_cast< const ::XMLMesh::el_t& > (i);
2766 
2767  o << ::std::endl << "v4: " << i.v4 ();
2768  return o;
2769  }
2770 
2771  static
2772  const ::xsd::cxx::tree::std_ostream_initializer< 0, char, q_t >
2773  _xsd_q_t_std_ostream_init;
2774 
2775  ::std::ostream&
2776  operator<< (::std::ostream& o, const edges_type& i)
2777  {
2779  b (i.ed ().begin ()), e (i.ed ().end ());
2780  b != e; ++b)
2781  {
2782  o << ::std::endl << "ed: " << *b;
2783  }
2784 
2785  return o;
2786  }
2787 
2788  ::std::ostream&
2789  operator<< (::std::ostream& o, const curves_type& i)
2790  {
2792  b (i.arc ().begin ()), e (i.arc ().end ());
2793  b != e; ++b)
2794  {
2795  o << ::std::endl << "arc: " << *b;
2796  }
2797 
2799  b (i.NURBS ().begin ()), e (i.NURBS ().end ());
2800  b != e; ++b)
2801  {
2802  o << ::std::endl << "NURBS: " << *b;
2803  }
2804 
2805  return o;
2806  }
2807 
2808  ::std::ostream&
2809  operator<< (::std::ostream& o, const refinements_type& i)
2810  {
2812  b (i.ref ().begin ()), e (i.ref ().end ());
2813  b != e; ++b)
2814  {
2815  o << ::std::endl << "ref: " << *b;
2816  }
2817 
2818  return o;
2819  }
2820 
2821  ::std::ostream&
2822  operator<< (::std::ostream& o, const mesh& i)
2823  {
2824  if (i.variables ())
2825  {
2826  o << ::std::endl << "variables: " << *i.variables ();
2827  }
2828 
2829  o << ::std::endl << "vertices: " << i.vertices ();
2830  o << ::std::endl << "elements: " << i.elements ();
2831  o << ::std::endl << "edges: " << i.edges ();
2832  if (i.curves ())
2833  {
2834  o << ::std::endl << "curves: " << *i.curves ();
2835  }
2836 
2837  if (i.refinements ())
2838  {
2839  o << ::std::endl << "refinements: " << *i.refinements ();
2840  }
2841 
2842  return o;
2843  }
2844 
2845  ::std::ostream&
2846  operator<< (::std::ostream& o, const var& i)
2847  {
2848  o << ::std::endl << "name: " << i.name ();
2849  o << ::std::endl << "value: " << i.value ();
2850  return o;
2851  }
2852 
2853  ::std::ostream&
2854  operator<< (::std::ostream& o, const v& i)
2855  {
2856  o << ::std::endl << "x: " << i.x ();
2857  o << ::std::endl << "y: " << i.y ();
2858  o << ::std::endl << "i: " << i.i ();
2859  return o;
2860  }
2861 
2862  ::std::ostream&
2863  operator<< (::std::ostream& o, const ed& i)
2864  {
2865  o << ::std::endl << "v1: " << i.v1 ();
2866  o << ::std::endl << "v2: " << i.v2 ();
2867  o << ::std::endl << "m: " << i.m ();
2868  return o;
2869  }
2870 
2871  ::std::ostream&
2872  operator<< (::std::ostream& o, const arc& i)
2873  {
2874  o << ::std::endl << "v1: " << i.v1 ();
2875  o << ::std::endl << "v2: " << i.v2 ();
2876  o << ::std::endl << "angle: " << i.angle ();
2877  return o;
2878  }
2879 
2880  ::std::ostream&
2881  operator<< (::std::ostream& o, const NURBS& i)
2882  {
2884  b (i.inner_point ().begin ()), e (i.inner_point ().end ());
2885  b != e; ++b)
2886  {
2887  o << ::std::endl << "inner_point: " << *b;
2888  }
2889 
2891  b (i.knot ().begin ()), e (i.knot ().end ());
2892  b != e; ++b)
2893  {
2894  o << ::std::endl << "knot: " << *b;
2895  }
2896 
2897  o << ::std::endl << "v1: " << i.v1 ();
2898  o << ::std::endl << "v2: " << i.v2 ();
2899  o << ::std::endl << "deg: " << i.deg ();
2900  return o;
2901  }
2902 
2903  ::std::ostream&
2904  operator<< (::std::ostream& o, const ref& i)
2905  {
2906  o << ::std::endl << "element_id: " << i.element_id ();
2907  o << ::std::endl << "refinement_type: " << i.refinement_type ();
2908  return o;
2909  }
2910 
2911  ::std::ostream&
2912  operator<< (::std::ostream& o, const inner_point& i)
2913  {
2914  o << ::std::endl << "x: " << i.x ();
2915  o << ::std::endl << "y: " << i.y ();
2916  o << ::std::endl << "weight: " << i.weight ();
2917  return o;
2918  }
2919 
2920  ::std::ostream&
2921  operator<< (::std::ostream& o, const knot& i)
2922  {
2923  o << ::std::endl << "value: " << i.value ();
2924  return o;
2925  }
2926 }
2927 
2928 #include <istream>
2929 #include <xsd/cxx/xml/sax/std-input-source.hxx>
2930 #include <xsd/cxx/tree/error-handler.hxx>
2931 
2932 namespace XMLMesh
2933 {
2934  ::std::auto_ptr< ::XMLMesh::mesh >
2936  ::xml_schema::flags f,
2938  {
2939  ::xsd::cxx::xml::auto_initializer i (
2940  (f & ::xml_schema::flags::dont_initialize) == 0,
2941  (f & ::xml_schema::flags::keep_dom) == 0);
2942 
2943  ::xsd::cxx::tree::error_handler< char > h;
2944 
2945  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
2946  ::xsd::cxx::xml::dom::parse< char > (
2947  u, h, p, f));
2948 
2949  h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
2950 
2951  ::std::auto_ptr< ::XMLMesh::mesh > r (
2952  ::XMLMesh::mesh_ (
2953  d, f | ::xml_schema::flags::own_dom, p));
2954 
2955  return r;
2956  }
2957 
2958  ::std::auto_ptr< ::XMLMesh::mesh >
2961  ::xml_schema::flags f,
2963  {
2964  ::xsd::cxx::xml::auto_initializer i (
2965  (f & ::xml_schema::flags::dont_initialize) == 0,
2966  (f & ::xml_schema::flags::keep_dom) == 0);
2967 
2968  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
2969  ::xsd::cxx::xml::dom::parse< char > (
2970  u, h, p, f));
2971 
2972  if (!d.get ())
2973  throw ::xsd::cxx::tree::parsing< char > ();
2974 
2975  ::std::auto_ptr< ::XMLMesh::mesh > r (
2976  ::XMLMesh::mesh_ (
2977  d, f | ::xml_schema::flags::own_dom, p));
2978 
2979  return r;
2980  }
2981 
2982  ::std::auto_ptr< ::XMLMesh::mesh >
2984  ::xercesc::DOMErrorHandler& h,
2985  ::xml_schema::flags f,
2987  {
2988  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
2989  ::xsd::cxx::xml::dom::parse< char > (
2990  u, h, p, f));
2991 
2992  if (!d.get ())
2993  throw ::xsd::cxx::tree::parsing< char > ();
2994 
2995  ::std::auto_ptr< ::XMLMesh::mesh > r (
2996  ::XMLMesh::mesh_ (
2997  d, f | ::xml_schema::flags::own_dom, p));
2998 
2999  return r;
3000  }
3001 
3002  ::std::auto_ptr< ::XMLMesh::mesh >
3003  mesh_ (::std::istream& is,
3004  ::xml_schema::flags f,
3006  {
3007  ::xsd::cxx::xml::auto_initializer i (
3008  (f & ::xml_schema::flags::dont_initialize) == 0,
3009  (f & ::xml_schema::flags::keep_dom) == 0);
3010 
3011  ::xsd::cxx::xml::sax::std_input_source isrc (is);
3012  return ::XMLMesh::mesh_ (isrc, f, p);
3013  }
3014 
3015  ::std::auto_ptr< ::XMLMesh::mesh >
3016  mesh_ (::std::istream& is,
3018  ::xml_schema::flags f,
3020  {
3021  ::xsd::cxx::xml::auto_initializer i (
3022  (f & ::xml_schema::flags::dont_initialize) == 0,
3023  (f & ::xml_schema::flags::keep_dom) == 0);
3024 
3025  ::xsd::cxx::xml::sax::std_input_source isrc (is);
3026  return ::XMLMesh::mesh_ (isrc, h, f, p);
3027  }
3028 
3029  ::std::auto_ptr< ::XMLMesh::mesh >
3030  mesh_ (::std::istream& is,
3031  ::xercesc::DOMErrorHandler& h,
3032  ::xml_schema::flags f,
3034  {
3035  ::xsd::cxx::xml::sax::std_input_source isrc (is);
3036  return ::XMLMesh::mesh_ (isrc, h, f, p);
3037  }
3038 
3039  ::std::auto_ptr< ::XMLMesh::mesh >
3040  mesh_ (::std::istream& is,
3041  const ::std::string& sid,
3042  ::xml_schema::flags f,
3044  {
3045  ::xsd::cxx::xml::auto_initializer i (
3046  (f & ::xml_schema::flags::dont_initialize) == 0,
3047  (f & ::xml_schema::flags::keep_dom) == 0);
3048 
3049  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
3050  return ::XMLMesh::mesh_ (isrc, f, p);
3051  }
3052 
3053  ::std::auto_ptr< ::XMLMesh::mesh >
3054  mesh_ (::std::istream& is,
3055  const ::std::string& sid,
3057  ::xml_schema::flags f,
3059  {
3060  ::xsd::cxx::xml::auto_initializer i (
3061  (f & ::xml_schema::flags::dont_initialize) == 0,
3062  (f & ::xml_schema::flags::keep_dom) == 0);
3063 
3064  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
3065  return ::XMLMesh::mesh_ (isrc, h, f, p);
3066  }
3067 
3068  ::std::auto_ptr< ::XMLMesh::mesh >
3069  mesh_ (::std::istream& is,
3070  const ::std::string& sid,
3071  ::xercesc::DOMErrorHandler& h,
3072  ::xml_schema::flags f,
3074  {
3075  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
3076  return ::XMLMesh::mesh_ (isrc, h, f, p);
3077  }
3078 
3079  ::std::auto_ptr< ::XMLMesh::mesh >
3080  mesh_ (::xercesc::InputSource& i,
3081  ::xml_schema::flags f,
3083  {
3084  ::xsd::cxx::tree::error_handler< char > h;
3085 
3086  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3087  ::xsd::cxx::xml::dom::parse< char > (
3088  i, h, p, f));
3089 
3090  h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
3091 
3092  ::std::auto_ptr< ::XMLMesh::mesh > r (
3093  ::XMLMesh::mesh_ (
3094  d, f | ::xml_schema::flags::own_dom, p));
3095 
3096  return r;
3097  }
3098 
3099  ::std::auto_ptr< ::XMLMesh::mesh >
3100  mesh_ (::xercesc::InputSource& i,
3102  ::xml_schema::flags f,
3104  {
3105  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3106  ::xsd::cxx::xml::dom::parse< char > (
3107  i, h, p, f));
3108 
3109  if (!d.get ())
3110  throw ::xsd::cxx::tree::parsing< char > ();
3111 
3112  ::std::auto_ptr< ::XMLMesh::mesh > r (
3113  ::XMLMesh::mesh_ (
3114  d, f | ::xml_schema::flags::own_dom, p));
3115 
3116  return r;
3117  }
3118 
3119  ::std::auto_ptr< ::XMLMesh::mesh >
3120  mesh_ (::xercesc::InputSource& i,
3121  ::xercesc::DOMErrorHandler& h,
3122  ::xml_schema::flags f,
3124  {
3125  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3126  ::xsd::cxx::xml::dom::parse< char > (
3127  i, h, p, f));
3128 
3129  if (!d.get ())
3130  throw ::xsd::cxx::tree::parsing< char > ();
3131 
3132  ::std::auto_ptr< ::XMLMesh::mesh > r (
3133  ::XMLMesh::mesh_ (
3134  d, f | ::xml_schema::flags::own_dom, p));
3135 
3136  return r;
3137  }
3138 
3139  ::std::auto_ptr< ::XMLMesh::mesh >
3140  mesh_ (const ::xercesc::DOMDocument& d,
3141  ::xml_schema::flags f,
3143  {
3144  if (f & ::xml_schema::flags::keep_dom)
3145  {
3146  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c (
3147  static_cast< ::xercesc::DOMDocument* > (d.cloneNode (true)));
3148 
3149  ::std::auto_ptr< ::XMLMesh::mesh > r (
3150  ::XMLMesh::mesh_ (
3151  c, f | ::xml_schema::flags::own_dom, p));
3152 
3153  return r;
3154  }
3155 
3156  const ::xercesc::DOMElement& e (*d.getDocumentElement ());
3157  const ::xsd::cxx::xml::qualified_name< char > n (
3158  ::xsd::cxx::xml::dom::name< char > (e));
3159 
3160  if (n.name () == "mesh" &&
3161  n.namespace_ () == "XMLMesh")
3162  {
3163  ::std::auto_ptr< ::XMLMesh::mesh > r (
3164  ::xsd::cxx::tree::traits< ::XMLMesh::mesh, char >::create (
3165  e, f, 0));
3166  return r;
3167  }
3168 
3169  throw ::xsd::cxx::tree::unexpected_element < char > (
3170  n.name (),
3171  n.namespace_ (),
3172  "mesh",
3173  "XMLMesh");
3174  }
3175 
3176  ::std::auto_ptr< ::XMLMesh::mesh >
3177  mesh_ (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >& d,
3178  ::xml_schema::flags f,
3180  {
3181  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c (
3182  ((f & ::xml_schema::flags::keep_dom) &&
3183  !(f & ::xml_schema::flags::own_dom))
3184  ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
3185  : 0);
3186 
3187  ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
3188  const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
3189 
3190  const ::xsd::cxx::xml::qualified_name< char > n (
3191  ::xsd::cxx::xml::dom::name< char > (e));
3192 
3193  if (f & ::xml_schema::flags::keep_dom)
3194  doc.setUserData (::xml_schema::dom::tree_node_key,
3195  (c.get () ? &c : &d),
3196  0);
3197 
3198  if (n.name () == "mesh" &&
3199  n.namespace_ () == "XMLMesh")
3200  {
3201  ::std::auto_ptr< ::XMLMesh::mesh > r (
3202  ::xsd::cxx::tree::traits< ::XMLMesh::mesh, char >::create (
3203  e, f, 0));
3204  return r;
3205  }
3206 
3207  throw ::xsd::cxx::tree::unexpected_element < char > (
3208  n.name (),
3209  n.namespace_ (),
3210  "mesh",
3211  "XMLMesh");
3212  }
3213 }
3214 
3215 #include <ostream>
3216 #include <xsd/cxx/tree/error-handler.hxx>
3217 #include <xsd/cxx/xml/dom/serialization-source.hxx>
3218 
3219 #include <xsd/cxx/tree/type-serializer-map.hxx>
3220 
3221 namespace _xsd
3222 {
3223  static
3224  const ::xsd::cxx::tree::type_serializer_plate< 0, char >
3225  type_serializer_plate_init;
3226 }
3227 
3228 namespace XMLMesh
3229 {
3230  void
3231  mesh_ (::std::ostream& o,
3232  const ::XMLMesh::mesh& s,
3235  ::xml_schema::flags f)
3236  {
3237  ::xsd::cxx::xml::auto_initializer i (
3238  (f & ::xml_schema::flags::dont_initialize) == 0);
3239 
3240  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3241  ::XMLMesh::mesh_ (s, m, f));
3242 
3243  ::xsd::cxx::tree::error_handler< char > h;
3244 
3245  ::xsd::cxx::xml::dom::ostream_format_target t (o);
3246  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3247  {
3248  h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
3249  }
3250  }
3251 
3252  void
3253  mesh_ (::std::ostream& o,
3254  const ::XMLMesh::mesh& s,
3258  ::xml_schema::flags f)
3259  {
3260  ::xsd::cxx::xml::auto_initializer i (
3261  (f & ::xml_schema::flags::dont_initialize) == 0);
3262 
3263  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3264  ::XMLMesh::mesh_ (s, m, f));
3265  ::xsd::cxx::xml::dom::ostream_format_target t (o);
3266  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3267  {
3268  throw ::xsd::cxx::tree::serialization< char > ();
3269  }
3270  }
3271 
3272  void
3273  mesh_ (::std::ostream& o,
3274  const ::XMLMesh::mesh& s,
3275  ::xercesc::DOMErrorHandler& h,
3278  ::xml_schema::flags f)
3279  {
3280  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3281  ::XMLMesh::mesh_ (s, m, f));
3282  ::xsd::cxx::xml::dom::ostream_format_target t (o);
3283  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3284  {
3285  throw ::xsd::cxx::tree::serialization< char > ();
3286  }
3287  }
3288 
3289  void
3290  mesh_ (::xercesc::XMLFormatTarget& t,
3291  const ::XMLMesh::mesh& s,
3294  ::xml_schema::flags f)
3295  {
3296  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3297  ::XMLMesh::mesh_ (s, m, f));
3298 
3299  ::xsd::cxx::tree::error_handler< char > h;
3300 
3301  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3302  {
3303  h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
3304  }
3305  }
3306 
3307  void
3308  mesh_ (::xercesc::XMLFormatTarget& t,
3309  const ::XMLMesh::mesh& s,
3313  ::xml_schema::flags f)
3314  {
3315  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3316  ::XMLMesh::mesh_ (s, m, f));
3317  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3318  {
3319  throw ::xsd::cxx::tree::serialization< char > ();
3320  }
3321  }
3322 
3323  void
3324  mesh_ (::xercesc::XMLFormatTarget& t,
3325  const ::XMLMesh::mesh& s,
3326  ::xercesc::DOMErrorHandler& h,
3329  ::xml_schema::flags f)
3330  {
3331  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3332  ::XMLMesh::mesh_ (s, m, f));
3333  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3334  {
3335  throw ::xsd::cxx::tree::serialization< char > ();
3336  }
3337  }
3338 
3339  void
3340  mesh_ (::xercesc::DOMDocument& d,
3341  const ::XMLMesh::mesh& s,
3343  {
3344  ::xercesc::DOMElement& e (*d.getDocumentElement ());
3345  const ::xsd::cxx::xml::qualified_name< char > n (
3346  ::xsd::cxx::xml::dom::name< char > (e));
3347 
3348  if (n.name () == "mesh" &&
3349  n.namespace_ () == "XMLMesh")
3350  {
3351  e << s;
3352  }
3353  else
3354  {
3355  throw ::xsd::cxx::tree::unexpected_element < char > (
3356  n.name (),
3357  n.namespace_ (),
3358  "mesh",
3359  "XMLMesh");
3360  }
3361  }
3362 
3363  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >
3364  mesh_ (const ::XMLMesh::mesh& s,
3366  ::xml_schema::flags f)
3367  {
3368  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
3369  ::xsd::cxx::xml::dom::serialize< char > (
3370  "mesh",
3371  "XMLMesh",
3372  m, f));
3373 
3374  ::XMLMesh::mesh_ (*d, s, f);
3375  return d;
3376  }
3377 
3378  void
3379  operator<< (::xercesc::DOMElement& e, const variables_type& i)
3380  {
3381  e << static_cast< const ::xml_schema::type& > (i);
3382 
3383  // var
3384  //
3386  b (i.var ().begin ()), n (i.var ().end ());
3387  b != n; ++b)
3388  {
3389  ::xercesc::DOMElement& s (
3390  ::xsd::cxx::xml::dom::create_element (
3391  "var",
3392  e));
3393 
3394  s << *b;
3395  }
3396  }
3397 
3398  void
3399  operator<< (::xercesc::DOMElement& e, const vertices_type& i)
3400  {
3401  e << static_cast< const ::xml_schema::type& > (i);
3402 
3403  // v
3404  //
3406  b (i.v ().begin ()), n (i.v ().end ());
3407  b != n; ++b)
3408  {
3409  ::xercesc::DOMElement& s (
3410  ::xsd::cxx::xml::dom::create_element (
3411  "v",
3412  e));
3413 
3414  s << *b;
3415  }
3416  }
3417 
3418  static
3419  const ::xsd::cxx::tree::element_serializer_initializer< 0, char, ::XMLMesh::t_t >
3420  _xsd_t_element_serializer_init (
3421  "el",
3422  "XMLMesh",
3423  "t",
3424  "XMLMesh");
3425 
3426 
3427  static
3428  const ::xsd::cxx::tree::element_serializer_initializer< 0, char, ::XMLMesh::q_t >
3429  _xsd_q_element_serializer_init (
3430  "el",
3431  "XMLMesh",
3432  "q",
3433  "XMLMesh");
3434 
3435 
3436  void
3437  operator<< (::xercesc::DOMElement& e, const elements_type& i)
3438  {
3439  e << static_cast< const ::xml_schema::type& > (i);
3440 
3441  // el
3442  //
3443  {
3444  ::xsd::cxx::tree::type_serializer_map< char >& tsm (
3445  ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
3446 
3448  b (i.el ().begin ()), n (i.el ().end ());
3449  b != n; ++b)
3450  {
3451  if (typeid (elements_type::el_type) == typeid (*b))
3452  {
3453  ::xercesc::DOMElement& s (
3454  ::xsd::cxx::xml::dom::create_element (
3455  "el",
3456  "XMLMesh",
3457  e));
3458 
3459  s << *b;
3460  }
3461  else
3462  tsm.serialize (
3463  "el",
3464  "XMLMesh",
3465  true, true, e, *b);
3466  }
3467  }
3468  }
3469 
3470  void
3471  operator<< (::xercesc::DOMElement& e, const el_t& i)
3472  {
3473  e << static_cast< const ::xml_schema::type& > (i);
3474 
3475  // v1
3476  //
3477  {
3478  ::xercesc::DOMAttr& a (
3479  ::xsd::cxx::xml::dom::create_attribute (
3480  "v1",
3481  e));
3482 
3483  a << i.v1 ();
3484  }
3485 
3486  // v2
3487  //
3488  {
3489  ::xercesc::DOMAttr& a (
3490  ::xsd::cxx::xml::dom::create_attribute (
3491  "v2",
3492  e));
3493 
3494  a << i.v2 ();
3495  }
3496 
3497  // v3
3498  //
3499  {
3500  ::xercesc::DOMAttr& a (
3501  ::xsd::cxx::xml::dom::create_attribute (
3502  "v3",
3503  e));
3504 
3505  a << i.v3 ();
3506  }
3507 
3508  // m
3509  //
3510  {
3511  ::xercesc::DOMAttr& a (
3512  ::xsd::cxx::xml::dom::create_attribute (
3513  "m",
3514  e));
3515 
3516  a << i.m ();
3517  }
3518  }
3519 
3520  static
3521  const ::xsd::cxx::tree::type_serializer_initializer< 0, char, el_t >
3522  _xsd_el_t_type_serializer_init (
3523  "el_t",
3524  "XMLMesh");
3525 
3526 
3527  void
3528  operator<< (::xercesc::DOMElement& e, const t_t& i)
3529  {
3530  e << static_cast< const ::XMLMesh::el_t& > (i);
3531  }
3532 
3533  static
3534  const ::xsd::cxx::tree::type_serializer_initializer< 0, char, t_t >
3535  _xsd_t_t_type_serializer_init (
3536  "t_t",
3537  "XMLMesh");
3538 
3539 
3540  void
3541  operator<< (::xercesc::DOMElement& e, const q_t& i)
3542  {
3543  e << static_cast< const ::XMLMesh::el_t& > (i);
3544 
3545  // v4
3546  //
3547  {
3548  ::xercesc::DOMAttr& a (
3549  ::xsd::cxx::xml::dom::create_attribute (
3550  "v4",
3551  e));
3552 
3553  a << i.v4 ();
3554  }
3555  }
3556 
3557  static
3558  const ::xsd::cxx::tree::type_serializer_initializer< 0, char, q_t >
3559  _xsd_q_t_type_serializer_init (
3560  "q_t",
3561  "XMLMesh");
3562 
3563 
3564  void
3565  operator<< (::xercesc::DOMElement& e, const edges_type& i)
3566  {
3567  e << static_cast< const ::xml_schema::type& > (i);
3568 
3569  // ed
3570  //
3572  b (i.ed ().begin ()), n (i.ed ().end ());
3573  b != n; ++b)
3574  {
3575  ::xercesc::DOMElement& s (
3576  ::xsd::cxx::xml::dom::create_element (
3577  "ed",
3578  e));
3579 
3580  s << *b;
3581  }
3582  }
3583 
3584  void
3585  operator<< (::xercesc::DOMElement& e, const curves_type& i)
3586  {
3587  e << static_cast< const ::xml_schema::type& > (i);
3588 
3589  // arc
3590  //
3592  b (i.arc ().begin ()), n (i.arc ().end ());
3593  b != n; ++b)
3594  {
3595  ::xercesc::DOMElement& s (
3596  ::xsd::cxx::xml::dom::create_element (
3597  "arc",
3598  e));
3599 
3600  s << *b;
3601  }
3602 
3603  // NURBS
3604  //
3606  b (i.NURBS ().begin ()), n (i.NURBS ().end ());
3607  b != n; ++b)
3608  {
3609  ::xercesc::DOMElement& s (
3610  ::xsd::cxx::xml::dom::create_element (
3611  "NURBS",
3612  e));
3613 
3614  s << *b;
3615  }
3616  }
3617 
3618  void
3619  operator<< (::xercesc::DOMElement& e, const refinements_type& i)
3620  {
3621  e << static_cast< const ::xml_schema::type& > (i);
3622 
3623  // ref
3624  //
3626  b (i.ref ().begin ()), n (i.ref ().end ());
3627  b != n; ++b)
3628  {
3629  ::xercesc::DOMElement& s (
3630  ::xsd::cxx::xml::dom::create_element (
3631  "ref",
3632  e));
3633 
3634  s << *b;
3635  }
3636  }
3637 
3638  void
3639  operator<< (::xercesc::DOMElement& e, const mesh& i)
3640  {
3641  e << static_cast< const ::xml_schema::type& > (i);
3642 
3643  // variables
3644  //
3645  if (i.variables ())
3646  {
3647  ::xercesc::DOMElement& s (
3648  ::xsd::cxx::xml::dom::create_element (
3649  "variables",
3650  e));
3651 
3652  s << *i.variables ();
3653  }
3654 
3655  // vertices
3656  //
3657  {
3658  ::xercesc::DOMElement& s (
3659  ::xsd::cxx::xml::dom::create_element (
3660  "vertices",
3661  e));
3662 
3663  s << i.vertices ();
3664  }
3665 
3666  // elements
3667  //
3668  {
3669  ::xercesc::DOMElement& s (
3670  ::xsd::cxx::xml::dom::create_element (
3671  "elements",
3672  e));
3673 
3674  s << i.elements ();
3675  }
3676 
3677  // edges
3678  //
3679  {
3680  ::xercesc::DOMElement& s (
3681  ::xsd::cxx::xml::dom::create_element (
3682  "edges",
3683  e));
3684 
3685  s << i.edges ();
3686  }
3687 
3688  // curves
3689  //
3690  if (i.curves ())
3691  {
3692  ::xercesc::DOMElement& s (
3693  ::xsd::cxx::xml::dom::create_element (
3694  "curves",
3695  e));
3696 
3697  s << *i.curves ();
3698  }
3699 
3700  // refinements
3701  //
3702  if (i.refinements ())
3703  {
3704  ::xercesc::DOMElement& s (
3705  ::xsd::cxx::xml::dom::create_element (
3706  "refinements",
3707  e));
3708 
3709  s << *i.refinements ();
3710  }
3711  }
3712 
3713  void
3714  operator<< (::xercesc::DOMElement& e, const var& i)
3715  {
3716  e << static_cast< const ::xml_schema::type& > (i);
3717 
3718  // name
3719  //
3720  {
3721  ::xercesc::DOMAttr& a (
3722  ::xsd::cxx::xml::dom::create_attribute (
3723  "name",
3724  e));
3725 
3726  a << i.name ();
3727  }
3728 
3729  // value
3730  //
3731  {
3732  ::xercesc::DOMAttr& a (
3733  ::xsd::cxx::xml::dom::create_attribute (
3734  "value",
3735  e));
3736 
3737  a << ::xml_schema::as_decimal(i.value ());
3738  }
3739  }
3740 
3741  void
3742  operator<< (::xercesc::DOMElement& e, const v& i)
3743  {
3744  e << static_cast< const ::xml_schema::type& > (i);
3745 
3746  // x
3747  //
3748  {
3749  ::xercesc::DOMAttr& a (
3750  ::xsd::cxx::xml::dom::create_attribute (
3751  "x",
3752  e));
3753 
3754  a << i.x ();
3755  }
3756 
3757  // y
3758  //
3759  {
3760  ::xercesc::DOMAttr& a (
3761  ::xsd::cxx::xml::dom::create_attribute (
3762  "y",
3763  e));
3764 
3765  a << i.y ();
3766  }
3767 
3768  // i
3769  //
3770  {
3771  ::xercesc::DOMAttr& a (
3772  ::xsd::cxx::xml::dom::create_attribute (
3773  "i",
3774  e));
3775 
3776  a << i.i ();
3777  }
3778  }
3779 
3780  void
3781  operator<< (::xercesc::DOMElement& e, const ed& i)
3782  {
3783  e << static_cast< const ::xml_schema::type& > (i);
3784 
3785  // v1
3786  //
3787  {
3788  ::xercesc::DOMAttr& a (
3789  ::xsd::cxx::xml::dom::create_attribute (
3790  "v1",
3791  e));
3792 
3793  a << i.v1 ();
3794  }
3795 
3796  // v2
3797  //
3798  {
3799  ::xercesc::DOMAttr& a (
3800  ::xsd::cxx::xml::dom::create_attribute (
3801  "v2",
3802  e));
3803 
3804  a << i.v2 ();
3805  }
3806 
3807  // m
3808  //
3809  {
3810  ::xercesc::DOMAttr& a (
3811  ::xsd::cxx::xml::dom::create_attribute (
3812  "m",
3813  e));
3814 
3815  a << i.m ();
3816  }
3817  }
3818 
3819  void
3820  operator<< (::xercesc::DOMElement& e, const arc& i)
3821  {
3822  e << static_cast< const ::xml_schema::type& > (i);
3823 
3824  // v1
3825  //
3826  {
3827  ::xercesc::DOMAttr& a (
3828  ::xsd::cxx::xml::dom::create_attribute (
3829  "v1",
3830  e));
3831 
3832  a << i.v1 ();
3833  }
3834 
3835  // v2
3836  //
3837  {
3838  ::xercesc::DOMAttr& a (
3839  ::xsd::cxx::xml::dom::create_attribute (
3840  "v2",
3841  e));
3842 
3843  a << i.v2 ();
3844  }
3845 
3846  // angle
3847  //
3848  {
3849  ::xercesc::DOMAttr& a (
3850  ::xsd::cxx::xml::dom::create_attribute (
3851  "angle",
3852  e));
3853 
3854  a << ::xml_schema::as_decimal(i.angle ());
3855  }
3856  }
3857 
3858  void
3859  operator<< (::xercesc::DOMElement& e, const NURBS& i)
3860  {
3861  e << static_cast< const ::xml_schema::type& > (i);
3862 
3863  // inner_point
3864  //
3866  b (i.inner_point ().begin ()), n (i.inner_point ().end ());
3867  b != n; ++b)
3868  {
3869  ::xercesc::DOMElement& s (
3870  ::xsd::cxx::xml::dom::create_element (
3871  "inner_point",
3872  e));
3873 
3874  s << *b;
3875  }
3876 
3877  // knot
3878  //
3880  b (i.knot ().begin ()), n (i.knot ().end ());
3881  b != n; ++b)
3882  {
3883  ::xercesc::DOMElement& s (
3884  ::xsd::cxx::xml::dom::create_element (
3885  "knot",
3886  e));
3887 
3888  s << *b;
3889  }
3890 
3891  // v1
3892  //
3893  {
3894  ::xercesc::DOMAttr& a (
3895  ::xsd::cxx::xml::dom::create_attribute (
3896  "v1",
3897  e));
3898 
3899  a << i.v1 ();
3900  }
3901 
3902  // v2
3903  //
3904  {
3905  ::xercesc::DOMAttr& a (
3906  ::xsd::cxx::xml::dom::create_attribute (
3907  "v2",
3908  e));
3909 
3910  a << i.v2 ();
3911  }
3912 
3913  // deg
3914  //
3915  {
3916  ::xercesc::DOMAttr& a (
3917  ::xsd::cxx::xml::dom::create_attribute (
3918  "deg",
3919  e));
3920 
3921  a << i.deg ();
3922  }
3923  }
3924 
3925  void
3926  operator<< (::xercesc::DOMElement& e, const ref& i)
3927  {
3928  e << static_cast< const ::xml_schema::type& > (i);
3929 
3930  // element_id
3931  //
3932  {
3933  ::xercesc::DOMAttr& a (
3934  ::xsd::cxx::xml::dom::create_attribute (
3935  "element_id",
3936  e));
3937 
3938  a << i.element_id ();
3939  }
3940 
3941  // refinement_type
3942  //
3943  {
3944  ::xercesc::DOMAttr& a (
3945  ::xsd::cxx::xml::dom::create_attribute (
3946  "refinement_type",
3947  e));
3948 
3949  a << i.refinement_type ();
3950  }
3951  }
3952 
3953  void
3954  operator<< (::xercesc::DOMElement& e, const inner_point& i)
3955  {
3956  e << static_cast< const ::xml_schema::type& > (i);
3957 
3958  // x
3959  //
3960  {
3961  ::xercesc::DOMAttr& a (
3962  ::xsd::cxx::xml::dom::create_attribute (
3963  "x",
3964  e));
3965 
3966  a << ::xml_schema::as_decimal(i.x ());
3967  }
3968 
3969  // y
3970  //
3971  {
3972  ::xercesc::DOMAttr& a (
3973  ::xsd::cxx::xml::dom::create_attribute (
3974  "y",
3975  e));
3976 
3977  a << ::xml_schema::as_decimal(i.y ());
3978  }
3979 
3980  // weight
3981  //
3982  {
3983  ::xercesc::DOMAttr& a (
3984  ::xsd::cxx::xml::dom::create_attribute (
3985  "weight",
3986  e));
3987 
3988  a << ::xml_schema::as_decimal(i.weight ());
3989  }
3990  }
3991 
3992  void
3993  operator<< (::xercesc::DOMElement& e, const knot& i)
3994  {
3995  e << static_cast< const ::xml_schema::type& > (i);
3996 
3997  // value
3998  //
3999  {
4000  ::xercesc::DOMAttr& a (
4001  ::xsd::cxx::xml::dom::create_attribute (
4002  "value",
4003  e));
4004 
4005  a << ::xml_schema::as_decimal(i.value ());
4006  }
4007  }
4008 }
4009 
4010 #include <xsd/cxx/post.hxx>
4011 
4012 // Begin epilogue.
4013 //
4014 //
4015 // End epilogue.
4016 
elements_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
virtual ~refinements_type()
Destructor.
Class corresponding to the q_t schema type.
refinements_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::integer v1_type
Attribute type.
virtual ~elements_type()
Destructor.
const var_sequence & var() const
Return a read-only (constant) reference to the element sequence.
::xml_schema::decimal angle_type
Attribute type.
Class corresponding to the t_t schema type.
::xml_schema::integer element_id_type
Attribute type.
virtual ~mesh()
Destructor.
::xml_schema::integer v1_type
Attribute type.
virtual q_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
Class corresponding to the ed schema type.
virtual ~inner_point()
Destructor.
::xsd::cxx::tree::sequence< knot_type > knot_sequence
Element sequence container type.
const v2_type & v2() const
Return a read-only (constant) reference to the attribute.
virtual ~NURBS()
Destructor.
::XMLMesh::el_t el_type
Element type.
Definition: mesh_h2d_xml.h:979
::xsd::cxx::tree::optional< variables_type > variables_optional
Element optional container type.
::xsd::cxx::tree::flags flags
Parsing and serialization flags.
::xml_schema::string m_type
Attribute type.
const ed_sequence & ed() const
Return a read-only (constant) reference to the element sequence.
const x_type & x() const
Return a read-only (constant) reference to the attribute.
const y_type & y() const
Return a read-only (constant) reference to the attribute.
virtual ~edges_type()
Destructor.
const refinement_type_type & refinement_type() const
Return a read-only (constant) reference to the attribute.
Class corresponding to the arc schema type.
const variables_optional & variables() const
Return a read-only (constant) reference to the element container.
Class corresponding to the v schema type.
const deg_type & deg() const
Return a read-only (constant) reference to the attribute.
Class corresponding to the knot schema type.
::xml_schema::string name_type
Attribute type.
virtual ~arc()
Destructor.
virtual ~el_t()
Destructor.
const x_type & x() const
Return a read-only (constant) reference to the attribute.
::xml_schema::decimal x_type
Attribute type.
Class corresponding to the NURBS schema type.
ed_sequence::const_iterator ed_const_iterator
Element constant iterator type.
const v3_type & v3() const
Return a read-only (constant) reference to the attribute.
const v4_type & v4() const
Return a read-only (constant) reference to the attribute.
arc(const v1_type &, const v2_type &, const angle_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
const v2_type & v2() const
Return a read-only (constant) reference to the attribute.
const refinements_optional & refinements() const
Return a read-only (constant) reference to the element container.
::xsd::cxx::tree::as_decimal< decimal > as_decimal
Serialization wrapper for the decimal type.
var_sequence::const_iterator var_const_iterator
Element constant iterator type.
Definition: mesh_h2d_xml.h:700
virtual variables_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
ref(const element_id_type &, const refinement_type_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::decimal weight_type
Attribute type.
::xml_schema::integer v2_type
Attribute type.
v(const x_type &, const y_type &, const i_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xsd::cxx::tree::sequence< ed_type > ed_sequence
Element sequence container type.
Class corresponding to the var schema type.
virtual v * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
const vertices_type & vertices() const
Return a read-only (constant) reference to the element.
NURBS(const v1_type &, const v2_type &, const deg_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
Class corresponding to the vertices_type schema type.
Definition: mesh_h2d_xml.h:818
const value_type & value() const
Return a read-only (constant) reference to the attribute.
::xsd::cxx::tree::type type
C++ type corresponding to the anyType XML Schema built-in type.
::xml_schema::integer i_type
Attribute type.
virtual ~ed()
Destructor.
virtual var * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
inner_point(const x_type &, const y_type &, const weight_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
el_sequence::const_iterator el_const_iterator
Element constant iterator type.
Definition: mesh_h2d_xml.h:994
el_t(const v1_type &, const v2_type &, const v3_type &, const m_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::decimal value_type
Attribute type.
virtual ~v()
Destructor.
::xsd::cxx::tree::sequence< v_type > v_sequence
Element sequence container type.
Definition: mesh_h2d_xml.h:837
Class corresponding to the mesh schema type.
ed(const v1_type &, const v2_type &, const m_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::integer v4_type
Attribute type.
const curves_optional & curves() const
Return a read-only (constant) reference to the element container.
const name_type & name() const
Return a read-only (constant) reference to the attribute.
inner_point_sequence::const_iterator inner_point_const_iterator
Element constant iterator type.
::xml_schema::integer refinement_type_type
Attribute type.
::xsd::cxx::tree::optional< curves_type > curves_optional
Element optional container type.
::std::auto_ptr< ::XMLMesh1D::mesh > mesh_(const ::std::string &uri,::xml_schema::flags f=0, const ::xml_schema::properties &p=::xml_schema::properties())
Parse a URI or a local file.
const m_type & m() const
Return a read-only (constant) reference to the attribute.
Generated from mesh_h2d_xml.xsd.
const v1_type & v1() const
Return a read-only (constant) reference to the attribute.
NURBS_sequence::const_iterator NURBS_const_iterator
Element constant iterator type.
ref_sequence::const_iterator ref_const_iterator
Element constant iterator type.
::xsd::cxx::tree::sequence< var_type > var_sequence
Element sequence container type.
Definition: mesh_h2d_xml.h:690
::xml_schema::integer v2_type
Attribute type.
const v1_type & v1() const
Return a read-only (constant) reference to the attribute.
const edges_type & edges() const
Return a read-only (constant) reference to the element.
virtual NURBS * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
virtual ~t_t()
Destructor.
::xsd::cxx::tree::name< char, token > name
C++ type corresponding to the Name XML Schema built-in type.
::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap
Namespace serialization information map.
const el_sequence & el() const
Return a read-only (constant) reference to the element sequence.
virtual ~q_t()
Destructor.
Class corresponding to the ref schema type.
Class corresponding to the elements_type schema type.
Definition: mesh_h2d_xml.h:965
::xml_schema::integer v2_type
Attribute type.
::xsd::cxx::tree::optional< refinements_type > refinements_optional
Element optional container type.
virtual el_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
virtual refinements_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
::xsd::cxx::xml::error_handler< char > error_handler
Error handler callback interface.
vertices_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
Class corresponding to the variables_type schema type.
Definition: mesh_h2d_xml.h:671
const XMLCh *const tree_node_key
DOM user data key for back pointers to tree nodes.
::xsd::cxx::tree::properties< char > properties
Parsing properties.
virtual edges_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
variables_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
virtual mesh * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
::xml_schema::string x_type
Attribute type.
::xml_schema::string y_type
Attribute type.
virtual knot * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
v_sequence::const_iterator v_const_iterator
Element constant iterator type.
Definition: mesh_h2d_xml.h:847
::xsd::cxx::tree::sequence< el_type > el_sequence
Element sequence container type.
Definition: mesh_h2d_xml.h:984
::xml_schema::decimal y_type
Attribute type.
const y_type & y() const
Return a read-only (constant) reference to the attribute.
::xml_schema::decimal value_type
Attribute type.
::xml_schema::integer v1_type
Attribute type.
virtual arc * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
t_t(const v1_type &, const v2_type &, const v3_type &, const m_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::string m_type
Attribute type.
virtual ed * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
const v2_type & v2() const
Return a read-only (constant) reference to the attribute.
C++ namespace for the http://www.w3.org/2001/XMLSchema schema namespace.
Class corresponding to the inner_point schema type.
curves_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
::xsd::cxx::tree::string< char, simple_type > string
C++ type corresponding to the string XML Schema built-in type.
virtual ~knot()
Destructor.
knot_sequence::const_iterator knot_const_iterator
Element constant iterator type.
var(const name_type &, const value_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
::xml_schema::integer deg_type
Attribute type.
const v2_type & v2() const
Return a read-only (constant) reference to the attribute.
const v1_type & v1() const
Return a read-only (constant) reference to the attribute.
const inner_point_sequence & inner_point() const
Return a read-only (constant) reference to the element sequence.
virtual curves_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
edges_type()
Create an instance from the ultimate base and initializers for required elements and attributes...
mesh(const vertices_type &, const elements_type &, const edges_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
C++ namespace for the XMLMesh schema namespace.
Definition: mesh_h2d_xml.h:624
::xsd::cxx::tree::sequence< NURBS_type > NURBS_sequence
Element sequence container type.
::xml_schema::integer v1_type
Attribute type.
::xsd::cxx::tree::sequence< arc_type > arc_sequence
Element sequence container type.
const element_id_type & element_id() const
Return a read-only (constant) reference to the attribute.
const knot_sequence & knot() const
Return a read-only (constant) reference to the element sequence.
const ref_sequence & ref() const
Return a read-only (constant) reference to the element sequence.
::xsd::cxx::tree::sequence< inner_point_type > inner_point_sequence
Element sequence container type.
virtual ref * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
::xsd::cxx::tree::type container
Alias for the anyType type.
virtual elements_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
virtual t_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
q_t(const v1_type &, const v2_type &, const v3_type &, const m_type &, const v4_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
const elements_type & elements() const
Return a read-only (constant) reference to the element.
::xml_schema::integer v3_type
Attribute type.
const value_type & value() const
Return a read-only (constant) reference to the attribute.
const NURBS_sequence & NURBS() const
Return a read-only (constant) reference to the element sequence.
const angle_type & angle() const
Return a read-only (constant) reference to the attribute.
::xsd::cxx::tree::sequence< ref_type > ref_sequence
Element sequence container type.
const arc_sequence & arc() const
Return a read-only (constant) reference to the element sequence.
Class corresponding to the edges_type schema type.
const v1_type & v1() const
Return a read-only (constant) reference to the attribute.
const v_sequence & v() const
Return a read-only (constant) reference to the element sequence.
::std::auto_ptr< ::XMLMesh::mesh > mesh_(const ::std::string &uri,::xml_schema::flags f=0, const ::xml_schema::properties &p=::xml_schema::properties())
Parse a URI or a local file.
virtual ~ref()
Destructor.
knot(const value_type &)
Create an instance from the ultimate base and initializers for required elements and attributes...
arc_sequence::const_iterator arc_const_iterator
Element constant iterator type.
virtual ~curves_type()
Destructor.
const m_type & m() const
Return a read-only (constant) reference to the attribute.
virtual inner_point * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
Class corresponding to the refinements_type schema type.
::xml_schema::integer v2_type
Attribute type.
virtual vertices_type * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Copy the instance polymorphically.
virtual ~var()
Destructor.
const weight_type & weight() const
Return a read-only (constant) reference to the attribute.
virtual ~vertices_type()
Destructor.
virtual ~variables_type()
Destructor.
const i_type & i() const
Return a read-only (constant) reference to the attribute.
Class corresponding to the el_t schema type.
Class corresponding to the curves_type schema type.